Improved trimming (#1458)

* Add threshold UI
* WIP Better trimming
* Rewrite mostly done WIP
* WIP - trim idea
* WIP threshold trimming
* WIP with new design
* Cleanup

firmware/application/apps/ui_iq_trim.cpp

@@ -30,41 +30,72 @@ namespace fs = std::filesystem;
 
 namespace ui {
 
-IQTrimView::IQTrimView(NavigationView& nav) {
+IQTrimView::IQTrimView(NavigationView& nav)
+    : nav_{nav} {
     add_children({
         &labels,
         &field_path,
-        &text_range,
+        &field_start,
+        &field_end,
+        &text_samples,
+        &text_max,
+        &field_cutoff,
         &button_trim,
     });
 
-    field_path.on_select = [this, &nav](TextField&) {
-        auto open_view = nav.push<FileLoadView>(".C*");
+    field_path.on_select = [this](TextField&) {
+        auto open_view = nav_.push<FileLoadView>(".C*");
         open_view->push_dir(u"CAPTURES");
         open_view->on_changed = [this](fs::path path) {
-            read_capture(path);
             path_ = std::move(path);
+            profile_capture();
+            compute_range();
             refresh_ui();
         };
     };
 
-    button_trim.on_select = [this, &nav](Button&) {
-        if (!path_.empty() && trim_range_.file_size > 0) {
-            progress_ui.show_trimming();
-            TrimFile(path_, trim_range_);
-            read_capture(path_);
+    text_samples.set_style(&Styles::light_grey);
+    text_max.set_style(&Styles::light_grey);
+
+    field_start.on_change = [this](int32_t v) {
+        if (field_end.value() < v)
+            field_end.set_value(v, false);
+        set_dirty();
+    };
+
+    field_end.on_change = [this](int32_t v) {
+        if (field_start.value() > v)
+            field_start.set_value(v, false);
+        set_dirty();
+    };
+
+    field_cutoff.set_value(7);  // 7% of max is a good default.
+    field_cutoff.on_change = [this](int32_t) {
+        compute_range();
+        refresh_ui();
+    };
+
+    button_trim.on_select = [this](Button&) {
+        if (trim_capture()) {
+            profile_capture();
+            compute_range();
             refresh_ui();
-        } else {
-            nav.display_modal("Error", "Select a file first.");
         }
     };
 }
 
 void IQTrimView::paint(Painter& painter) {
-    if (!path_.empty()) {
+    if (info_) {
+        uint32_t power_cutoff = field_cutoff.value() * static_cast<uint64_t>(info_->max_power) / 100;
+
         // Draw power buckets.
         for (size_t i = 0; i < power_buckets_.size(); ++i) {
-            auto amp = power_buckets_[i].power;
+            auto power = power_buckets_[i].power;
+            uint8_t amp = 0;
+
+            if (power > power_cutoff && info_->max_power > 0)
+                amp = (255ULL * power) / info_->max_power;
+
             painter.draw_vline(
                 pos_lines + Point{(int)i, 0},
                 height_lines,
@@ -72,8 +103,8 @@ void IQTrimView::paint(Painter& painter) {
         }
 
         // Draw trim range edges.
-        int start_x = screen_width * trim_range_.start / trim_range_.file_size;
-        int end_x = screen_width * trim_range_.end / trim_range_.file_size;
+        int start_x = screen_width * field_start.value() / info_->sample_count;
+        int end_x = screen_width * field_end.value() / info_->sample_count;
 
         painter.draw_vline(
             pos_lines + Point{start_x, 0},
@@ -92,27 +123,72 @@ void IQTrimView::focus() {
 
 void IQTrimView::refresh_ui() {
     field_path.set_text(path_.filename().string());
-    text_range.set(to_string_dec_uint(trim_range_.start) + "-" + to_string_dec_uint(trim_range_.end));
+    text_samples.set(to_string_dec_uint(info_->sample_count));
+    text_max.set(to_string_dec_uint(info_->max_power));
     set_dirty();
 }
 
-bool IQTrimView::read_capture(const fs::path& path) {
+void IQTrimView::update_range_controls(iq::TrimRange trim_range) {
+    auto max_range = info_ ? info_->sample_count : 0;
+    auto step = info_ ? info_->sample_count / screen_width : 0;
+
+    field_start.set_range(0, max_range);
+    field_start.set_step(step);
+    field_end.set_range(0, max_range);
+    field_end.set_step(step);
+
+    field_start.set_value(trim_range.start_sample, false);
+    field_end.set_value(trim_range.end_sample, false);
+}
+
+void IQTrimView::profile_capture() {
     power_buckets_ = {};
-    PowerBuckets buckets{
+    iq::PowerBuckets buckets{
         .p = power_buckets_.data(),
         .size = power_buckets_.size()};
 
     progress_ui.show_reading();
-    auto range = ComputeTrimRange(path, amp_threshold, &buckets, progress_ui.get_callback());
+    info_ = iq::profile_capture(path_, buckets);
     progress_ui.clear();
-
-    if (range) {
-        trim_range_ = *range;
-        return true;
-    } else {
-        trim_range_ = {};
-        return false;
-    }
 }
 
-}  // namespace ui
+void IQTrimView::compute_range() {
+    if (!info_)
+        return;
+
+    iq::PowerBuckets buckets{
+        .p = power_buckets_.data(),
+        .size = power_buckets_.size()};
+    auto trim_range = iq::compute_trim_range(*info_, buckets, field_cutoff.value());
+
+    update_range_controls(trim_range);
+}
+
+bool IQTrimView::trim_capture() {
+    if (!info_) {
+        nav_.display_modal("Error", "Open a file first.");
+        return false;
+    }
+
+    bool trimmed = false;
+    iq::TrimRange trim_range{
+        static_cast<uint32_t>(field_start.value()),
+        static_cast<uint32_t>(field_end.value()),
+        info_->sample_size};
+
+    if (trim_range.start_sample >= trim_range.end_sample) {
+        nav_.display_modal("Error", "Invalid trimming range.");
+        return false;
+    }
+
+    progress_ui.show_trimming();
+    trimmed = iq::trim_capture_with_range(path_, trim_range, progress_ui.get_callback());
+    progress_ui.clear();
+
+    if (!trimmed)
+        nav_.display_modal("Error", "Trimming failed.");
+
+    return trimmed;
+}
+
+}  // namespace ui