Increase REC BW Option till 1Mhz Capture App (#1352 )

* Increase REC BW Option till 1Mhz Capture App * Format issues * miss type correction * format issues
Reject bmp images that aren't 240 pixels wide (#1351 )
2026-09-13 18:19:33 +00:00 · 2023-08-06 21:54:24 +02:00 · 2023-08-05 17:14:18 +02:00 · 2023-08-04 07:56:39 +02:00 · 2023-08-02 21:59:26 +02:00 · 2023-08-02 10:24:23 +12:00
67 changed files with 1378 additions and 695 deletions
@@ -29,7 +29,7 @@ def print_nightly_changelog():


 def handle_get_request(path, offset=None):
-    headers = {"Authorization": f"Bearer {token}"}
+    headers = {} if token == None else {"Authorization": f"Bearer {token}"}
    params = {"since": offset}
    url_base = f"https://api.github.com/repos/{repo_owner}/{repo_name}/"
    response = requests.get(url_base + path, headers=headers, params=params)
@@ -1 +1 @@
-v1.7.2
+v1.7.3
@@ -1 +1 @@
-v1.7.3
+v1.7.4
@@ -48,9 +48,9 @@ class AMOptionsView : public View {

    OptionsField options_config{
        {3 * 8, 0 * 16},
-        6,  // number of blanking characters
+        6,  // Max option length
        {
-            // using  common messages from freqman.cpp
+            // Using common messages from freqman_ui.cpp
        }};
 };

@@ -65,9 +65,9 @@ class NBFMOptionsView : public View {
    };
    OptionsField options_config{
        {3 * 8, 0 * 16},
-        4,
+        3,  // Max option length
        {
-            // using  common messages from freqman.cpp
+            // Using common messages from freqman_ui.cpp
        }};

    Text text_squelch{
@@ -93,9 +93,9 @@ class WFMOptionsView : public View {
    };
    OptionsField options_config{
        {3 * 8, 0 * 16},
-        4,
+        4,  // Max option length
        {
-            // using  common messages from freqman.cpp
+            // Using common messages from freqman_ui.cpp
        }};
 };

@@ -51,6 +51,7 @@ CaptureAppView::CaptureAppView(NavigationView& nav)
    field_frequency_step.set_by_value(receiver_model.frequency_step());
    field_frequency_step.on_change = [this](size_t, OptionsField::value_t v) {
        receiver_model.set_frequency_step(v);
+        this->field_frequency.set_step(v);
    };

    option_format.set_selected_index(0);  // Default to C16
@@ -59,19 +60,28 @@ CaptureAppView::CaptureAppView(NavigationView& nav)
    };

    freqman_set_bandwidth_option(SPEC_MODULATION, option_bandwidth);
-    option_bandwidth.on_change = [this](size_t, uint32_t base_rate) {
-        /* base_rate is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
-        /* ex. sampling_rate values, 4Mhz, when recording 500 kHz (BW) and fs 8 Mhz, when selected 1 Mhz BW ... */
-        /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card  */
-        auto sampling_rate = 8 * base_rate;  // Decimation by 8 done on baseband side.
+    option_bandwidth.on_change = [this](size_t, uint32_t bandwidth) {
+        /* Nyquist would imply a sample rate of 2x bandwidth, but because the ADC
+         * provides 2 values (I,Q), the sample_rate is equal to bandwidth here. */
+        auto sample_rate = bandwidth;

-        /* Set up proper anti aliasing BPF bandwith in MAX2837 before ADC sampling according to the new added BW Options. */
-        auto anti_alias_baseband_bandwidth_filter = filter_bandwidth_for_sampling_rate(sampling_rate);
+        /* base_rate (bandwidth) is used for FFT calculation and display LCD, and also in recording writing SD Card rate. */
+        /* ex. sampling_rate values, 4Mhz, when recording 500 kHz (BW) and fs 8 Mhz, when selected 1 Mhz BW ... */
+        /* ex. recording 500kHz BW to .C16 file, base_rate clock 500kHz x2(I,Q) x 2 bytes (int signed) =2MB/sec rate SD Card. */

        waterfall.stop();
-        record_view.set_sampling_rate(sampling_rate);
-        receiver_model.set_sampling_rate(sampling_rate);
-        receiver_model.set_baseband_bandwidth(anti_alias_baseband_bandwidth_filter);
+
+        // record_view determines the correct oversampling to apply and returns the actual sample rate.
+        // NB: record_view is what actually updates proc_capture baseband settings.
+        auto actual_sample_rate = record_view.set_sampling_rate(sample_rate);
+
+        // Update the radio model with the actual sampling rate.
+        receiver_model.set_sampling_rate(actual_sample_rate);
+
+        // Get suitable anti-aliasing BPF bandwidth for MAX2837 given the actual sample rate.
+        auto anti_alias_filter_bandwidth = filter_bandwidth_for_sampling_rate(actual_sample_rate);
+        receiver_model.set_baseband_bandwidth(anti_alias_filter_bandwidth);
+
        waterfall.start();
    };

@@ -63,17 +63,15 @@ void GpsSimAppView::on_file_changed(const fs::path& new_file_path) {

    if (metadata) {
        field_frequency.set_value(metadata->center_frequency);
-        sample_rate = metadata->sample_rate;
-    } else {
-        sample_rate = 2600000;
+        transmitter_model.set_sampling_rate(metadata->sample_rate);
    }

    // UI Fixup.
-    text_sample_rate.set(unit_auto_scale(sample_rate, 3, 1) + "Hz");
+    text_sample_rate.set(unit_auto_scale(transmitter_model.sampling_rate(), 3, 1) + "Hz");
    progressbar.set_max(file_size);
    text_filename.set(truncate(file_path.filename().string(), 12));

-    auto duration = ms_duration(file_size, sample_rate, 2);
+    auto duration = ms_duration(file_size, transmitter_model.sampling_rate(), 2);
    text_duration.set(to_string_time_ms(duration));

    button_play.focus();
@@ -129,7 +127,6 @@ void GpsSimAppView::start() {
            });
    }

-    transmitter_model.set_sampling_rate(sample_rate);
    transmitter_model.enable();
 }

@@ -176,6 +173,11 @@ GpsSimAppView::GpsSimAppView(
        &waterfall,
    });

+    if (!settings_.loaded()) {
+        field_frequency.set_value(initial_target_frequency);
+        transmitter_model.set_sampling_rate(2600000);
+    }
+
    field_frequency.set_step(5000);

    button_play.on_select = [this](ImageButton&) {
@@ -54,6 +54,8 @@ class GpsSimAppView : public View {
    std::string title() const override { return "GPS Sim TX"; };

   private:
+    static constexpr uint32_t initial_target_frequency = 1575420000;
+
    NavigationView& nav_;
    RxRadioState radio_state_{
        3000000 /* bandwidth */,
@@ -64,7 +66,6 @@ class GpsSimAppView : public View {

    static constexpr ui::Dim header_height = 3 * 16;

-    uint32_t sample_rate = 0;
    int32_t tx_gain{47};
    bool rf_amp{true};                                       // aux private var to store temporal, same as Replay App rf_amp user selection.
    static constexpr uint32_t baseband_bandwidth = 3000000;  // filter bandwidth
@@ -124,7 +124,7 @@ void ReplayAppView::start() {

    if (reader) {
        button_play.set_bitmap(&bitmap_stop);
-        baseband::set_sample_rate(sample_rate * 8);
+        baseband::set_sample_rate(sample_rate, OversampleRate::x8);

        replay_thread = std::make_unique<ReplayThread>(
            std::move(reader),
@@ -136,7 +136,7 @@ void ReplayAppView::start() {
            });
    }

-    transmitter_model.set_sampling_rate(sample_rate * 8);
+    transmitter_model.set_sampling_rate(sample_rate * toUType(OversampleRate::x8));
    transmitter_model.set_baseband_bandwidth(baseband_bandwidth);
    transmitter_model.enable();

@@ -251,7 +251,7 @@ void ControlsSwitchesWidget::on_show() {

 bool ControlsSwitchesWidget::on_key(const KeyEvent key) {
    key_event_mask = 1 << toUType(key);
-    long_press_key_event_mask = switch_long_press_occurred((size_t)key) ? key_event_mask : 0;
+    long_press_key_event_mask = key_is_long_pressed(key) ? key_event_mask : 0;
    return true;
 }

@@ -264,9 +264,9 @@ void ControlsSwitchesWidget::paint(Painter& painter) {
        {32, 64, 16, 16},  // Down
        {32, 0, 16, 16},   // Up
        {32, 32, 16, 16},  // Select
+        {96, 0, 16, 16},   // Dfu
        {16, 96, 16, 16},  // Encoder phase 0
        {48, 96, 16, 16},  // Encoder phase 1
-        {96, 0, 16, 16},   // Dfu
        {96, 64, 16, 16},  // Touch
    }};

@@ -283,9 +283,9 @@ void ControlsSwitchesWidget::paint(Painter& painter) {
        {32 + 1, 64 + 1, 16 - 2, 16 - 2},  // Down
        {32 + 1, 0 + 1, 16 - 2, 16 - 2},   // Up
        {32 + 1, 32 + 1, 16 - 2, 16 - 2},  // Select
+        {96 + 1, 0 + 1, 16 - 2, 16 - 2},   // Dfu
        {16 + 1, 96 + 1, 16 - 2, 16 - 2},  // Encoder phase 0
        {48 + 1, 96 + 1, 16 - 2, 16 - 2},  // Encoder phase 1
-        {96 + 1, 0 + 1, 16 - 2, 16 - 2},   // Dfu
    }};

    auto switches_raw = control::debug::switches();
@@ -354,13 +354,13 @@ DebugControlsView::DebugControlsView(NavigationView& nav) {
    });

    button_done.on_select = [&nav](Button&) {
-        switches_long_press_enable(0);
+        set_switches_long_press_config(0);
        nav.pop();
    };

    options_switches_mode.on_change = [this](size_t, OptionsField::value_t v) {
        (void)v;
-        switches_long_press_enable(options_switches_mode.selected_index_value());
+        set_switches_long_press_config(options_switches_mode.selected_index_value());
    };
 }

@@ -403,11 +403,17 @@ void FileManagerView::refresh_widgets(const bool v) {
    set_dirty();
 }

-void FileManagerView::on_rename() {
+void FileManagerView::on_rename(std::string_view hint) {
    auto& entry = get_selected_entry();
-    name_buffer = entry.path.filename().string();
-    uint32_t cursor_pos = (uint32_t)name_buffer.length();

+    // Append the hint to the filename stem as a rename suggestion.
+    name_buffer = entry.path.stem().string();
+    if (!hint.empty())
+        name_buffer += "_" + std::string{hint};
+    name_buffer += entry.path.extension().string();
+
+    // Set the rename cursor to before the extension to make renaming simpler.
+    uint32_t cursor_pos = (uint32_t)name_buffer.length();
    if (auto pos = name_buffer.find_last_of(".");
        pos != name_buffer.npos && !entry.is_directory)
        cursor_pos = pos;
@@ -434,6 +440,11 @@ void FileManagerView::on_rename() {
 }

 void FileManagerView::on_delete() {
+    if (is_directory(get_selected_full_path()) && !is_empty_directory(get_selected_full_path())) {
+        nav_.display_modal("Delete", "Directory not empty!");
+        return;
+    }
+
    auto name = get_selected_entry().path.filename().string();
    nav_.push<ModalMessageView>(
        "Delete", "Delete " + name + "\nAre you sure?", YESNO,
@@ -545,6 +556,7 @@ FileManagerView::FileManagerView(
        &button_new_dir,
        &button_new_file,
        &button_open_notepad,
+        &button_rename_timestamp,
    });

    menu_view.on_highlight = [this]() {
@@ -568,7 +580,7 @@ FileManagerView::FileManagerView(

    button_rename.on_select = [this]() {
        if (selected_is_valid())
-            on_rename();
+            on_rename("");
    };

    button_delete.on_select = [this]() {
@@ -614,6 +626,13 @@ FileManagerView::FileManagerView(
        } else
            nav_.display_modal("Open in Notepad", "Can't open that in Notepad.");
    };
+
+    button_rename_timestamp.on_select = [this]() {
+        if (selected_is_valid() && !get_selected_entry().is_directory) {
+            on_rename(::truncate(to_string_timestamp(rtc_time::now()), 8));
+        } else
+            nav_.display_modal("Timestamp Rename", "Can't rename that.");
+    };
 }

 }  // namespace ui
@@ -207,7 +207,7 @@ class FileManagerView : public FileManBaseView {
    ClipboardMode clipboard_mode{ClipboardMode::None};

    void refresh_widgets(const bool v);
-    void on_rename();
+    void on_rename(std::string_view hint);
    void on_delete();
    void on_paste();
    void on_new_dir();
@@ -272,6 +272,12 @@ class FileManagerView : public FileManBaseView {
        {},
        &bitmap_icon_notepad,
        Color::orange()};
+
+    NewButton button_rename_timestamp{
+        {4 * 8, 34 * 8, 4 * 8, 32},
+        {},
+        &bitmap_icon_options_datetime,
+        Color::orange()};
 };

 } /* namespace ui */
@@ -487,7 +487,7 @@ void FrequencyEditView::populate_bandwidth_options() {

    if (entry_.modulation < std::size(freqman_bandwidths)) {
        auto& bandwidths = freqman_bandwidths[entry_.modulation];
-        for (auto i = 1u; i < bandwidths.size(); ++i) {
+        for (auto i = 0u; i < bandwidths.size(); ++i) {
            auto& item = bandwidths[i];
            options.push_back({item.first, (OptionsField::value_t)i});
        }
@@ -500,7 +500,7 @@ void FrequencyEditView::populate_step_options() {
    OptionsField::options_t options;
    options.push_back({"None", -1});

-    for (auto i = 1u; i < freqman_steps.size(); ++i) {
+    for (auto i = 0u; i < freqman_steps.size(); ++i) {
        auto& item = freqman_steps[i];
        options.push_back({item.first, (OptionsField::value_t)i});
    }
@@ -513,7 +513,7 @@ void FrequencyEditView::populate_tone_options() {
    OptionsField::options_t options;
    options.push_back({"None", -1});

-    for (auto i = 1u; i < tone_keys.size(); ++i) {
+    for (auto i = 0u; i < tone_keys.size(); ++i) {
        auto& item = tone_keys[i];
        options.push_back({fx100_string(item.second), (OptionsField::value_t)i});
    }
@@ -219,12 +219,15 @@ class FrequencyEditView : public View {
        {{0 * 8, 10 * 16}, "Description:", Color::light_grey()},
    };

-    OptionsField field_type{{13 * 8, 3 * 16}, 8, {
-                                                     {"Single", 0},
-                                                     {"Range", 1},
-                                                     {"HamRadio", 2},
-                                                     {"Raw", 3},
-                                                 }};
+    OptionsField field_type{
+        {13 * 8, 3 * 16},
+        8,
+        {
+            {"Single", 0},
+            {"Range", 1},
+            {"HamRadio", 2},
+            {"Raw", 3},
+        }};

    FrequencyField field_freq_a{{13 * 8, 4 * 16}};

@@ -24,18 +24,18 @@

 #include "ui_playlist.hpp"

+#include "baseband_api.hpp"
 #include "convert.hpp"
 #include "file_reader.hpp"
 #include "io_file.hpp"
 #include "io_convert.hpp"
-
+#include "oversample.hpp"
+#include "portapack.hpp"
+#include "portapack_persistent_memory.hpp"
 #include "string_format.hpp"
 #include "ui_fileman.hpp"
 #include "utility.hpp"

-#include "baseband_api.hpp"
-#include "portapack.hpp"
-#include "portapack_persistent_memory.hpp"
 #include <unistd.h>
 #include <fstream>

@@ -266,17 +266,16 @@ void PlaylistView::send_current_track() {
        return;
    }

-    // ReplayThread starts immediately on construction so
-    // these need to be set before creating the ReplayThread.
+    // Update the sample rate in proc_replay baseband.
+    baseband::set_sample_rate(current()->metadata.sample_rate,
+                              get_oversample_rate(current()->metadata.sample_rate));
+
+    // ReplayThread starts immediately on construction; must be set before creating.
    transmitter_model.set_target_frequency(current()->metadata.center_frequency);
-    transmitter_model.set_sampling_rate(current()->metadata.sample_rate * 8);
+    transmitter_model.set_sampling_rate(get_actual_sample_rate(current()->metadata.sample_rate));
    transmitter_model.set_baseband_bandwidth(baseband_bandwidth);
    transmitter_model.enable();

-    // Set baseband sample rate too for waterfall to be correct.
-    // TODO: Why doesn't the transmitter_model just handle this?
-    baseband::set_sample_rate(transmitter_model.sampling_rate());
-
    // Reset the transmit progress bar.
    progressbar_transmit.set_value(0);

@@ -859,18 +859,12 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
    uint32_t local_recon_lock_duration = recon_lock_duration;

    chrono_end = chTimeNow();
-    if (field_mode.selected_index_value() == SPEC_MODULATION) {
-        time_interval = chrono_end - chrono_start;
-        // capping here to avoid double check a frequency because time_interval is more than exactly 100 by a few units
-        // this is because we are making a measurement and not using a fixed value
-        if (time_interval > 100)
-            time_interval = 100;
-        if (field_lock_wait.value() == 0) {
-            if (time_interval <= 1)             // capping here to avoid freeze because too quick
-                local_recon_lock_duration = 2;  // minimum working tested value
-            else
-                local_recon_lock_duration = time_interval;
-        }
+    time_interval = chrono_end - chrono_start;
+    if (field_lock_wait.value() == 0) {
+        if (time_interval <= 1)             // capping here to avoid freeze because too quick
+            local_recon_lock_duration = 2;  // minimum working tested value
+        else
+            local_recon_lock_duration = time_interval;
    }
    chrono_start = chrono_end;

@@ -907,7 +901,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
            if (db > squelch)  // MATCHING LEVEL
            {
                freq_lock++;
-                timer += time_interval;  // give some more time for next lock
+                timer += local_recon_lock_duration;  // give some more time for next lock
            } else {
                // continuous, direct cut it if not consecutive match after 1 first match
                if (recon_match_mode == RECON_MATCH_CONTINUOUS) {
@@ -961,7 +955,7 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
    }

    if (timer != 0) {
-        timer -= time_interval;
+        timer -= local_recon_lock_duration;
        if (timer < 0) {
            timer = 0;
        }
@@ -1234,10 +1228,10 @@ size_t ReconView::change_mode(freqman_index_t new_mod) {
            break;
        case SPEC_MODULATION:
            freqman_set_bandwidth_option(new_mod, field_bw);
-            // bw 200k (0) default
+            // bw 12k5 (0) default
+            field_bw.set_by_value(0);
            baseband::run_image(portapack::spi_flash::image_tag_capture);
            receiver_model.set_modulation(ReceiverModel::Mode::Capture);
-            field_bw.set_by_value(0);
            field_bw.on_change = [this](size_t, OptionsField::value_t sampling_rate) {
                auto anti_alias_baseband_bandwidth_filter = filter_bandwidth_for_sampling_rate(sampling_rate);
                record_view->set_sampling_rate(sampling_rate);
@@ -1251,8 +1245,9 @@ size_t ReconView::change_mode(freqman_index_t new_mod) {
    }
    if (new_mod != SPEC_MODULATION) {
        button_audio_app.set_text("AUDIO");
+        // TODO: Oversampling.
        record_view->set_sampling_rate(recording_sampling_rate);
-        // reset receiver model to fix bug when going from SPEC to audio, the sound is distorded
+        // reset receiver model to fix bug when going from SPEC to audio, the sound is distorted
        receiver_model.set_sampling_rate(3072000);
        receiver_model.set_baseband_bandwidth(1750000);
    } else {
@@ -69,10 +69,11 @@ ReconSetupViewMain::ReconSetupViewMain(NavigationView& nav, Rect parent_rect, st

    button_save_freqs.on_select = [this, &nav](Button&) {
        auto open_view = nav.push<FileLoadView>(".TXT");
+        open_view->push_dir(freqman_dir);
        open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
            if (new_file_path.native().find(freqman_dir.native()) == 0) {
                _output_file = new_file_path.stem().string();
-                text_input_file.set(_output_file);
+                button_output_file.set_text(_output_file);
            } else {
                nav.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
            }
@@ -21,20 +21,25 @@
 */

 #include "ui_scanner.hpp"
+
+#include "optional.hpp"
 #include "ui_fileman.hpp"
 #include "ui_freqman.hpp"

 using namespace portapack;
+namespace fs = std::filesystem;

 namespace ui {

+static const fs::path default_scan_file{u"FREQMAN/SCANNER.TXT"};
+
 ScannerThread::ScannerThread(std::vector<rf::Frequency> frequency_list)
    : frequency_list_{std::move(frequency_list)} {
    _manual_search = false;
    create_thread();
 }

-ScannerThread::ScannerThread(const jammer::jammer_range_t& frequency_range, size_t def_step_hz)
+ScannerThread::ScannerThread(const scanner_range_t& frequency_range, size_t def_step_hz)
    : frequency_range_(frequency_range), def_step_hz_(def_step_hz) {
    _manual_search = true;
    create_thread();
@@ -80,7 +85,7 @@ void ScannerThread::set_freq_del(const rf::Frequency v) {
 }

 // Force a one-time forward or reverse frequency index change; OK to do this without pausing scan thread
-//(used when rotary encoder is turned)
+// (used when rotary encoder is turned)
 void ScannerThread::set_index_stepper(const int32_t v) {
    _index_stepper = v;
 }
@@ -228,17 +233,26 @@ void ScannerView::handle_retune(int64_t freq, uint32_t freq_idx) {
    }

    if (!manual_search) {
-        if (frequency_list.size() > 0) {
+        if (entries.size() > 0)
            text_current_index.set(to_string_dec_uint(freq_idx + 1, 3));
-        }

-        if (freq_idx < description_list.size() && description_list[freq_idx].size() > 1)
-            desc_current_index.set(description_list[freq_idx]);  // Show description from file
+        if (freq_idx < entries.size() && entries[freq_idx].description.size() > 1)
+            text_current_desc.set(entries[freq_idx].description);  // Show description from file
        else
-            desc_current_index.set(desc_freq_list_scan);  // Show Scan file name (no description in file)
+            text_current_desc.set(loaded_filename());  // Show Scan file name (no description in file)
    }
 }

+std::string ScannerView::loaded_filename() const {
+    auto filename = loaded_path.filename().string();
+    if (filename.length() > 23) {  // Truncate and add ellipses if long file name
+        filename.resize(22);
+        filename = filename + "+";
+    }
+
+    return filename;
+}
+
 void ScannerView::focus() {
    button_load.focus();
 }
@@ -254,46 +268,46 @@ ScannerView::~ScannerView() {
 void ScannerView::show_max_index() {  // show total number of freqs to scan
    text_current_index.set("---");

-    if (frequency_list.size() == FREQMAN_MAX_PER_FILE) {
+    if (entries.size() == FREQMAN_MAX_PER_FILE) {
        text_max_index.set_style(&Styles::red);
        text_max_index.set("/ " + to_string_dec_uint(FREQMAN_MAX_PER_FILE) + " (DB MAX!)");
    } else {
        text_max_index.set_style(&Styles::grey);
-        text_max_index.set("/ " + to_string_dec_uint(frequency_list.size()));
+        text_max_index.set("/ " + to_string_dec_uint(entries.size()));
    }
 }

 ScannerView::ScannerView(
    NavigationView& nav)
-    : nav_{nav}, loaded_file_name{"SCANNER"} {
-    add_children({&labels,
-                  &field_lna,
-                  &field_vga,
-                  &field_rf_amp,
-                  &field_volume,
-                  &field_bw,
-                  &field_squelch,
-                  &field_browse_wait,
-                  &field_lock_wait,
-                  &button_load,
-                  &button_clear,
-                  &rssi,
-                  &text_current_index,
-                  &text_max_index,
-                  &desc_current_index,
-                  &big_display,
-                  &button_manual_start,
-                  &button_manual_end,
-                  &field_mode,
-                  &field_step,
-                  &button_manual_search,
-                  &button_pause,
-                  &button_dir,
-                  &button_audio_app,
-                  &button_mic_app,
-                  &button_add,
-                  &button_remove
-
+    : nav_{nav} {
+    add_children({
+        &labels,
+        &field_lna,
+        &field_vga,
+        &field_rf_amp,
+        &field_volume,
+        &field_bw,
+        &field_squelch,
+        &field_browse_wait,
+        &field_lock_wait,
+        &button_load,
+        &button_clear,
+        &rssi,
+        &text_current_index,
+        &text_max_index,
+        &text_current_desc,
+        &big_display,
+        &button_manual_start,
+        &button_manual_end,
+        &field_mode,
+        &field_step,
+        &button_manual_search,
+        &button_pause,
+        &button_dir,
+        &button_audio_app,
+        &button_mic_app,
+        &button_add,
+        &button_remove,
    });

    // Populate option text for these fields
@@ -312,14 +326,14 @@ ScannerView::ScannerView(
    frequency_range.max = stored_freq + 1000000;
    button_manual_end.set_text(to_string_short_freq(frequency_range.max));

-    // Button to load txt files from the FREQMAN folder
+    // Button to load a Freqman file.
    button_load.on_select = [this, &nav](Button&) {
        auto open_view = nav.push<FileLoadView>(".TXT");
        open_view->push_dir(freqman_dir);
        open_view->on_changed = [this, &nav](std::filesystem::path new_file_path) {
            if (new_file_path.native().find(freqman_dir.native()) == 0) {
                scan_pause();
-                frequency_file_load(new_file_path.stem().string(), true);
+                frequency_file_load(new_file_path);
            } else {
                nav.display_modal("LOAD ERROR", "A valid file from\nFREQMAN directory is\nrequired.");
            }
@@ -328,14 +342,13 @@ ScannerView::ScannerView(

    // Button to clear in-memory frequency list
    button_clear.on_select = [this, &nav](Button&) {
-        if (scan_thread && frequency_list.size()) {
+        if (scan_thread && entries.size()) {
            scan_thread->stop();  // STOP SCANNER THREAD
-            frequency_list.clear();
-            description_list.clear();
+            entries.clear();

            show_max_index();  // UPDATE new list size on screen
            text_current_index.set("");
-            desc_current_index.set(desc_freq_list_scan);
+            text_current_desc.set(loaded_filename());
            scan_thread->set_freq_lock(0);  // Reset the scanner lock

            // FUTURE: Consider switching to manual search mode automatically after clear (but would need to validate freq range)
@@ -404,16 +417,15 @@ ScannerView::ScannerView(

    // Button to delete current frequency from scan Freq List
    button_remove.on_select = [this](Button&) {
-        if (scan_thread && (frequency_list.size() > current_index)) {
+        if (scan_thread && (entries.size() > current_index)) {
            scan_thread->set_scanning(false);  // PAUSE Scanning if necessary

-            // Remove frequency from the Freq List in memory (it is not removed from the file)
-            scan_thread->set_freq_del(frequency_list[current_index]);
-            description_list.erase(description_list.begin() + current_index);
-            frequency_list.erase(frequency_list.begin() + current_index);
+            // Remove frequency from the Freq List in memory (it is not removed from the file).
+            scan_thread->set_freq_del(entries[current_index].freq);
+            entries.erase(entries.begin() + current_index);

            show_max_index();               // UPDATE new list size on screen
-            desc_current_index.set("");     // Clean up description (cosmetic detail)
+            text_current_desc.set("");      // Clean up description (cosmetic detail)
            scan_thread->set_freq_lock(0);  // Reset the scanner lock
        }
    };
@@ -432,15 +444,7 @@ ScannerView::ScannerView(
            manual_search = false;  // Switch to List Scan mode
        }

-        audio::output::stop();
-
-        if (scan_thread)
-            scan_thread->stop();  // STOP SCANNER THREAD
-
-        if (userpause)  // If user-paused, resume
-            user_resume();
-
-        start_scan_thread();  // RESTART SCANNER THREAD in selected mode
+        restart_scan();
    };

    // Mode field was changed (AM/NFM/WFM)
@@ -467,17 +471,8 @@ ScannerView::ScannerView(
    field_step.on_change = [this](size_t, OptionsField::value_t v) {
        receiver_model.set_frequency_step(v);

-        if (manual_search && scan_thread) {
-            // Restart scan thread with new step value
-            scan_thread->stop();  // STOP SCANNER THREAD
-
-            // Resuming pause automatically
-            // FUTURE: Consider whether we should stay in Pause mode...
-            if (userpause)  // If user-paused, resume
-                user_resume();
-
-            start_scan_thread();  // RESTART SCANNER THREAD in Manual Search mode
-        }
+        if (manual_search && scan_thread)
+            restart_scan();
    };

    // Button to toggle Forward/Reverse
@@ -491,68 +486,37 @@ ScannerView::ScannerView(
        bigdisplay_update(BDC_GREY);  // Back to grey color
    };

-    // TODO: remove this parsing?
    // Button to add current frequency (found during Search) to the Scan Frequency List
    button_add.on_select = [this](Button&) {
-        File scanner_file;
-        const std::string freq_file_path = "FREQMAN/" + loaded_file_name + ".TXT";
-        auto result = scanner_file.open(freq_file_path);  // First search if freq is already in txt
+        FreqmanDB db;
+        if (db.open(loaded_path, /*create*/ true)) {
+            freqman_entry entry{
+                .frequency_a = current_frequency,
+                .type = freqman_type::Single,
+            };

-        if (!result.is_valid()) {
-            const std::string frequency_to_add = "f=" + to_string_dec_uint(current_frequency / 1000) + to_string_dec_uint(current_frequency % 1000UL, 3, '0');
-
-            bool found = false;
-            constexpr size_t buffer_size = 1024;
-            char buffer[buffer_size];
-
-            for (size_t pointer = 0, freq_str_idx = 0; pointer < scanner_file.size(); pointer += buffer_size) {
-                size_t adjusted_buffer_size;
-                if (pointer + buffer_size >= scanner_file.size()) {
-                    memset(buffer, 0, sizeof(buffer));
-                    adjusted_buffer_size = scanner_file.size() - pointer;
-                } else {
-                    adjusted_buffer_size = buffer_size;
-                }
-
-                scanner_file.seek(pointer);
-                scanner_file.read(buffer, adjusted_buffer_size);
-
-                for (size_t i = 0; i < adjusted_buffer_size; ++i) {
-                    if (buffer[i] == frequency_to_add.data()[freq_str_idx]) {
-                        ++freq_str_idx;
-                        if (freq_str_idx >= frequency_to_add.size()) {
-                            found = true;
-                            break;
-                        }
-                    } else {
-                        freq_str_idx = 0;
-                    }
-                }
-
-                if (found) {
-                    break;
-                }
-            }
+            // Look for existing entry with same frequency.
+            auto it = db.find_entry([&entry](const auto& e) {
+                return e.frequency_a == entry.frequency_a;
+            });
+            auto found = (it != db.end());

            if (found) {
                nav_.display_modal("Error", "Frequency already exists");
-                bigdisplay_update(-1);  // After showing an error
+                bigdisplay_update(-1);  // Need to poke this control after displaying modal?
            } else {
-                scanner_file.append(freq_file_path);  // Second: append if it is not there
-                scanner_file.write_line(frequency_to_add);
-
+                db.append_entry(entry);
                // Add to frequency_list in memory too, since we can now switch back from manual mode
-                // Note that we are allowing freqs to be added to file (code above) that exceed the max count we can load into memory
-                if (frequency_list.size() < FREQMAN_MAX_PER_FILE) {
-                    frequency_list.push_back(current_frequency);
-                    description_list.push_back("");
-
+                // Note that we are allowing freqs to be added to file (code above) that exceed the
+                // max count we can load into memory.
+                if (entries.size() < FREQMAN_MAX_PER_FILE) {
+                    entries.push_back({current_frequency, ""});
                    show_max_index();  // Display updated frequency list size
                }
            }
        } else {
-            nav_.display_modal("Error", "Cannot open " + loaded_file_name + ".TXT\nfor appending freq.");
-            bigdisplay_update(-1);  // After showing an error
+            nav_.display_modal("Error", "Cannot open " + loaded_path.filename().string() + "\nfor appending freq.");
+            bigdisplay_update(-1);  // Need to poke this control after displaying modal?
        }
    };

@@ -566,106 +530,76 @@ ScannerView::ScannerView(
    field_squelch.on_change = [this](int32_t v) { squelch = v; };
    field_squelch.set_value(-30);

-    // LEARN FREQUENCIES
-    std::string scanner_txt = "SCANNER";
-    frequency_file_load(scanner_txt);
+    // LOAD FREQUENCIES
+    frequency_file_load(default_scan_file);
 }

-void ScannerView::frequency_file_load(std::string file_name, bool stop_all_before) {
-    bool found_range{false};
-    bool found_single{false};
+void ScannerView::frequency_file_load(const fs::path& path) {
    freqman_index_t def_mod_index{freqman_invalid_index};
    freqman_index_t def_bw_index{freqman_invalid_index};
    freqman_index_t def_step_index{freqman_invalid_index};

-    // stop everything running now if required
-    if (stop_all_before) {
-        scan_thread->stop();
-        frequency_list.clear();  // clear the existing frequency list (expected behavior)
-        description_list.clear();
+    FreqmanDB db;
+    if (!db.open(path)) {
+        text_current_desc.set("NO " + path.filename().string());
+        loaded_path = default_scan_file;
+        return;
    }

-    if (load_freqman_file(file_name, database, {})) {
-        loaded_file_name = file_name;
-        for (auto& entry_ptr : database) {
-            if (frequency_list.size() >= FREQMAN_MAX_PER_FILE)
+    entries.clear();
+    loaded_path = path;
+    Optional<scanner_range_t> range;
+
+    for (auto entry : db) {
+        if (is_invalid(def_mod_index))
+            def_mod_index = entry.modulation;
+
+        if (is_invalid(def_bw_index))
+            def_bw_index = entry.bandwidth;
+
+        if (is_invalid(def_step_index))
+            def_step_index = entry.step;
+
+        switch (entry.type) {
+            case freqman_type::Single:
+                entries.push_back({entry.frequency_a, entry.description});
+                break;
+            case freqman_type::HamRadio:
+                entries.push_back({entry.frequency_a, "R: " + entry.description});
+                entries.push_back({entry.frequency_b, "T: " + entry.description});
+                break;
+            case freqman_type::Range:
+                // NB: Only the first range will be loaded.
+                if (!range)
+                    range = {entry.frequency_a, entry.frequency_b};
+                break;
+            default:
                break;
-
-            auto& entry = *entry_ptr;
-
-            // Get modulation & bw & step from file if specified
-            // Note these values could be different for each line in the file, but we only look at the first one
-            //
-            // Note that freqman requires a very specific string for these parameters,
-            // so check syntax in frequency file if specified value isn't being loaded
-            //
-            if (is_invalid(def_mod_index))
-                def_mod_index = entry.modulation;
-
-            if (is_invalid(def_bw_index))
-                def_bw_index = entry.bandwidth;
-
-            if (is_invalid(def_step_index))
-                def_step_index = entry.step;
-
-            // Get frequency
-            if (entry.type == freqman_type::Range) {
-                if (!found_range) {
-                    // Set Start & End Search Range instead of populating the small in-memory frequency table
-                    // NOTE:  There may be multiple single frequencies in file, but only one search range is supported.
-                    found_range = true;
-                    frequency_range.min = entry.frequency_a;
-                    button_manual_start.set_text(to_string_short_freq(frequency_range.min));
-                    frequency_range.max = entry.frequency_b;
-                    button_manual_end.set_text(to_string_short_freq(frequency_range.max));
-                }
-            } else if (entry.type == freqman_type::Single) {
-                found_single = true;
-                frequency_list.push_back(entry.frequency_a);
-                description_list.push_back(entry.description);
-            } else if (entry.type == freqman_type::HamRadio) {
-                // For HAM repeaters, add both receive & transmit frequencies to scan list and modify description
-                // (FUTURE fw versions might handle these differently)
-                found_single = true;
-                frequency_list.push_back(entry.frequency_a);
-                description_list.push_back("R:" + entry.description);
-
-                if ((entry.frequency_a != entry.frequency_b) &&
-                    (frequency_list.size() < FREQMAN_MAX_PER_FILE)) {
-                    frequency_list.push_back(entry.frequency_b);
-                    description_list.push_back("T:" + entry.description);
-                }
-            }
        }
-    } else {
-        loaded_file_name = "SCANNER";  // back to the default frequency file
-        desc_current_index.set(" NO " + file_name + ".TXT FILE ...");
-    }

-    desc_freq_list_scan = loaded_file_name + ".TXT";
-    if (desc_freq_list_scan.length() > 23) {  // Truncate description and add ellipses if long file name
-        desc_freq_list_scan.resize(20);
-        desc_freq_list_scan = desc_freq_list_scan + "...";
+        if (entries.size() >= FREQMAN_MAX_PER_FILE)
+            break;
    }

    if (is_valid(def_mod_index) && def_mod_index != (freqman_index_t)field_mode.selected_index_value())
-        field_mode.set_by_value(def_mod_index);  // Update mode (also triggers a change callback that disables & reenables RF background)
+        field_mode.set_by_value(def_mod_index);

-    if (is_valid(def_bw_index))  // Update BW if specified in file
+    if (is_valid(def_bw_index))
        field_bw.set_selected_index(def_bw_index);

-    if (is_valid(def_step_index))  // Update step if specified in file
+    if (is_valid(def_step_index))
        field_step.set_selected_index(def_step_index);

-    audio::output::stop();
+    // Found range, set it and update UI.
+    if (range) {
+        frequency_range = *range;
+        button_manual_start.set_text(to_string_short_freq(frequency_range.min));
+        button_manual_end.set_text(to_string_short_freq(frequency_range.max));
+    }

-    if (userpause)  // If user-paused, resume
-        user_resume();
-
-    // Scan list if we found one, otherwise do manual range search
-    manual_search = !found_single;
-
-    start_scan_thread();
+    // Scan entries if any, otherwise do manual range search.
+    manual_search = entries.empty();
+    restart_scan();
 }

 void ScannerView::update_squelch_while_paused(int32_t max_db) {
@@ -754,7 +688,8 @@ void ScannerView::user_resume() {
    userpause = false;                                            // Resume scanning
 }

-void ScannerView::change_mode(freqman_index_t new_mod) {  // Before this, do a scan_thread->stop();  After this do a start_scan_thread()
+// Before this, do a scan_thread->stop();  After this do a start_scan_thread()
+void ScannerView::change_mode(freqman_index_t new_mod) {
    using option_t = std::pair<std::string, int32_t>;
    using options_t = std::vector<option_t>;
    options_t bw;
@@ -791,22 +726,41 @@ void ScannerView::change_mode(freqman_index_t new_mod) {  // Before this, do a s

 void ScannerView::start_scan_thread() {
    receiver_model.enable();
+    // Disable squelch on the model because RSSI handler is where the
+    // actual squelching is applied for this app.
    receiver_model.set_squelch_level(0);
    show_max_index();

    // Start Scanner Thread
-    // FUTURE: Consider passing additional control flags (fwd,userpause,etc) to scanner thread at start (perhaps in a data structure)
    if (manual_search) {
        button_manual_search.set_text("SCAN");  // Update meaning of Manual Scan button
-        desc_current_index.set(desc_freq_range_search);
+        text_current_desc.set("SEARCHING...");
        scan_thread = std::make_unique<ScannerThread>(frequency_range, field_step.selected_index_value());
    } else {
        button_manual_search.set_text("SRCH");  // Update meaning of Manual Scan button
-        desc_current_index.set(desc_freq_list_scan);
-        scan_thread = std::make_unique<ScannerThread>(frequency_list);
+        text_current_desc.set(loaded_filename());
+
+        // TODO: just pass ref to the thread?
+        std::vector<rf::Frequency> frequency_list;
+        frequency_list.reserve(entries.size());
+        for (const auto& entry : entries)
+            frequency_list.push_back(entry.freq);
+
+        scan_thread = std::make_unique<ScannerThread>(std::move(frequency_list));
    }

    scan_thread->set_scanning_direction(fwd);
 }

+void ScannerView::restart_scan() {
+    audio::output::stop();
+    if (scan_thread)  // STOP SCANNER THREAD
+        scan_thread->stop();
+
+    if (userpause)  // If user-paused, resume
+        user_resume();
+
+    start_scan_thread();  // RESTART SCANNER THREAD in selected mode
+}
+
 } /* namespace ui */
@@ -20,19 +20,20 @@
 * Boston, MA 02110-1301, USA.
 */

-#include "ui.hpp"
-#include "receiver_model.hpp"
+#include "audio.hpp"
+#include "analog_audio_app.hpp"
+#include "baseband_api.hpp"
+#include "file.hpp"
+#include "freqman.hpp"
+#include "freqman_db.hpp"
+#include "portapack_persistent_memory.hpp"
 #include "radio_state.hpp"
+#include "receiver_model.hpp"
+#include "string_format.hpp"
+#include "ui.hpp"
+#include "ui_mictx.hpp"
 #include "ui_receiver.hpp"
 #include "ui_styles.hpp"
-#include "freqman.hpp"
-#include "analog_audio_app.hpp"
-#include "audio.hpp"
-#include "ui_mictx.hpp"
-#include "portapack_persistent_memory.hpp"
-#include "baseband_api.hpp"
-#include "string_format.hpp"
-#include "file.hpp"

 #define SCANNER_SLEEP_MS 50  // ms that Scanner Thread sleeps per loop
 #define STATISTICS_UPDATES_PER_SEC 10
@@ -40,10 +41,28 @@

 namespace ui {

+// TODO: There is too much duplicated data in these classes.
+// ScannerThread should just use more from the View.
+// Or perhaps ScannerThread should just be in the View.
+
+// TODO: Too many functions mix work and UI update.
+// Consolidate UI fixup to a single function.
+
+// TODO: Just use freqman_entry.
+struct scanner_entry_t {
+    rf::Frequency freq;
+    std::string description;
+};
+
+struct scanner_range_t {
+    int64_t min;
+    int64_t max;
+};
+
 class ScannerThread {
   public:
    ScannerThread(std::vector<rf::Frequency> frequency_list);
-    ScannerThread(const jammer::jammer_range_t& frequency_range, size_t def_step_hz);
+    ScannerThread(const scanner_range_t& frequency_range, size_t def_step_hz);
    ~ScannerThread();

    void set_scanning(const bool v);
@@ -65,7 +84,7 @@ class ScannerThread {

   private:
    std::vector<rf::Frequency> frequency_list_{};
-    jammer::jammer_range_t frequency_range_{false, 0, 0};
+    scanner_range_t frequency_range_{0, 0};
    size_t def_step_hz_{0};
    Thread* thread{nullptr};

@@ -89,10 +108,6 @@ class ScannerView : public View {
    void focus() override;

    std::string title() const override { return "Scanner"; };
-    std::vector<rf::Frequency> frequency_list{};
-    std::vector<std::string> description_list{};
-
-    // void set_parent_rect(const Rect new_parent_rect) override;

   private:
    app_settings::SettingsManager settings_{
@@ -102,18 +117,21 @@ class ScannerView : public View {
    RxRadioState radio_state_{};

    void start_scan_thread();
+    void restart_scan();
    void change_mode(freqman_index_t mod_type);
    void show_max_index();
    void scan_pause();
    void scan_resume();
    void user_resume();
-    void frequency_file_load(std::string file_name, bool stop_all_before = false);
+    void frequency_file_load(const std::filesystem::path& path);
    void bigdisplay_update(int32_t);
    void update_squelch_while_paused(int32_t max_db);
    void on_statistics_update(const ChannelStatistics& statistics);
    void handle_retune(int64_t freq, uint32_t freq_idx);

-    jammer::jammer_range_t frequency_range{false, 0, 0};  // perfect for manual scan task too...
+    std::string loaded_filename() const;
+
+    scanner_range_t frequency_range{0, 0};
    int32_t squelch{0};
    uint32_t browse_timer{0};
    uint32_t lock_timer{0};
@@ -122,10 +140,12 @@ class ScannerView : public View {
    rf::Frequency bigdisplay_current_frequency{0};
    uint32_t browse_wait{0};
    uint32_t lock_wait{0};
-    freqman_db database{};
-    std::string loaded_file_name;
+
+    std::filesystem::path loaded_path{};
+    std::vector<scanner_entry_t> entries{};
    uint32_t current_index{0};
    rf::Frequency current_frequency{0};
+
    bool userpause{false};
    bool manual_search{false};
    bool fwd{true};  // to preserve direction setting even if scan_thread restarted
@@ -137,9 +157,6 @@ class ScannerView : public View {
        BDC_RED
    };

-    std::string desc_freq_range_search = "SEARCHING...";
-    std::string desc_freq_list_scan = "";
-
    Labels labels{
        {{0 * 8, 0 * 16}, "LNA:   VGA:   AMP:  VOL:", Color::light_grey()},
        {{0 * 8, 1 * 16}, "BW:       SQ:    Wsa:   Wsl:", Color::light_grey()},
@@ -204,7 +221,7 @@ class ScannerView : public View {
        {4 * 8, 3 * 16, 18 * 8, 16},
    };

-    Text desc_current_index{
+    Text text_current_desc{
        {0, 4 * 16, 240 - 6 * 8, 16},
    };

@@ -480,12 +480,10 @@ class SetEncoderDialView : public View {

    OptionsField field_encoder_dial_sensitivity{
        {20 * 8, 3 * 16},
-        7,
-        {{"LOWEST", encoder_dial_sensitivity::DIAL_SENSITIVITY_LOWEST},
-         {"LOW", encoder_dial_sensitivity::DIAL_SENSITIVITY_LOW},
+        6,
+        {{"LOW", encoder_dial_sensitivity::DIAL_SENSITIVITY_LOW},
         {"NORMAL", encoder_dial_sensitivity::DIAL_SENSITIVITY_NORMAL},
-         {"HIGH", encoder_dial_sensitivity::DIAL_SENSITIVITY_HIGH},
-         {"HIGHEST", encoder_dial_sensitivity::DIAL_SENSITIVITY_HIGHEST}}};
+         {"HIGH", encoder_dial_sensitivity::DIAL_SENSITIVITY_HIGH}}};

    Button button_save{
        {2 * 8, 16 * 16, 12 * 8, 32},
@@ -72,6 +72,7 @@ void TextViewer::paint(Painter& painter) {
        paint_state_.first_line = first_line;
        paint_state_.first_col = first_col;
        paint_state_.redraw_text = true;
+        paint_state_.line = UINT32_MAX;  // forget old cursor position when overwritten
    }

    if (paint_state_.redraw_text) {
@@ -221,6 +222,10 @@ void TextViewer::paint_text(Painter& painter, uint32_t line, uint16_t col) {
                 r.top() + (int)i * char_height,
                 clear_width * char_width, char_height},
                style().background);
+
+        // if cursor line got overwritten, disable XOR of old cursor when displaying new cursor
+        if (i == paint_state_.line)
+            paint_state_.line = UINT32_MAX;
    }
 }

@@ -228,21 +233,32 @@ void TextViewer::paint_cursor(Painter& painter) {
    if (!has_focus())
        return;

-    auto draw_cursor = [this, &painter](uint32_t line, uint16_t col, Color c) {
-        auto r = screen_rect();
-        line = line - paint_state_.first_line;
-        col = col - paint_state_.first_col;
+    auto xor_cursor = [this, &painter](int32_t line, uint16_t col) {
+        int cursor_width = char_width + 1;
+        int x = (col - paint_state_.first_col) * char_width - 1;
+        if (x < 0) {  // cursor is one pixel narrower when in left column
+            cursor_width--;
+            x = 0;
+        }
+        int y = screen_rect().top() + (line - paint_state_.first_line) * char_height;

-        painter.draw_rectangle(
-            {(int)col * char_width - 1,
-             r.top() + (int)line * char_height,
-             char_width + 1, char_height},
-            c);
+        // Converting one row at a time to reduce buffer size
+        auto pbuf8 = cursor_.pixel_buffer8;
+        auto pbuf = cursor_.pixel_buffer;
+        for (auto col = 0; col < char_height; col++) {
+            // Annoyingly, read_pixels uses a 24-bit pixel format vs draw_pixels which uses 16-bit
+            portapack::display.read_pixels({x, y + col, cursor_width, 1}, pbuf8, cursor_width);
+            for (auto i = 0; i < cursor_width; i++)
+                pbuf[i] = Color(pbuf8[i].r, pbuf8[i].g, pbuf8[i].b).v ^ 0xFFFF;
+            portapack::display.draw_pixels({x, y + col, cursor_width, 1}, pbuf, cursor_width);
+        }
    };

-    // Clear old cursor. CONSIDER: XOR cursor?
-    draw_cursor(paint_state_.line, paint_state_.col, style().background);
-    draw_cursor(cursor_.line, cursor_.col, style().foreground);
+    if (paint_state_.line != UINT32_MAX)  // only XOR old cursor if it still appears on the screen
+        xor_cursor(paint_state_.line, paint_state_.col);
+
+    xor_cursor(cursor_.line, cursor_.col);
+
    paint_state_.line = cursor_.line;
    paint_state_.col = cursor_.col;
 }
@@ -325,7 +341,7 @@ static void show_save_prompt(
    std::function<void()> on_save,
    std::function<void()> continuation) {
    nav.display_modal(
-        "Save?", "Save changes?", YESNO,
+        "Save?", "       Save changes?", YESNO,
        [on_save](bool choice) {
            if (choice && on_save)
                on_save();
@@ -458,7 +474,13 @@ void TextEditorView::open_file(const fs::path& path) {
    path_ = {};
    file_dirty_ = false;
    has_temp_file_ = false;
-    auto result = FileWrapper::open(path);
+    auto result = FileWrapper::open(
+        path, false, [](uint32_t value, uint32_t total) {
+            Painter p;
+            auto percent = (value * 100) / total;
+            auto width = (percent * screen_width) / 100;
+            p.draw_hline({0, 16}, width, Color::yellow());
+        });

    if (!result) {
        nav_.display_modal("Read Error", "Cannot open file:\n" + result.error().what());
@@ -566,6 +588,10 @@ void TextEditorView::prepare_for_write() {
    if (has_temp_file_)
        return;

+    // TODO: This would be nice to have but it causes a stack overflow in an ISR?
+    // Painter p;
+    // p.draw_string({2, 48}, Styles::yellow, "Creating temporary file...");
+
    // Copy to temp file on write.
    has_temp_file_ = true;
    delete_temp_file(path_);
@@ -117,6 +117,10 @@ class TextViewer : public Widget {
        uint32_t line{};
        uint16_t col{};
        ScrollDirection dir{ScrollDirection::Vertical};
+
+        // Pixel buffer used for cursor XOR'ing - Max cursor width = Max char width + 1
+        ColorRGB888 pixel_buffer8[ui::char_width + 1]{};
+        Color pixel_buffer[ui::char_width + 1]{};
    } cursor_{};
 };

@@ -347,8 +347,8 @@ void spectrum_streaming_stop() {
    send_message(&message);
 }

-void set_sample_rate(const uint32_t sample_rate) {
-    SamplerateConfigMessage message{sample_rate};
+void set_sample_rate(uint32_t sample_rate, OversampleRate oversample_rate) {
+    SampleRateConfigMessage message{sample_rate, oversample_rate};
    send_message(&message);
 }

@@ -94,7 +94,8 @@ void shutdown();
 void spectrum_streaming_start();
 void spectrum_streaming_stop();

-void set_sample_rate(const uint32_t sample_rate);
+/* NB: sample_rate should be desired rate. Don't pre-scale. */
+void set_sample_rate(uint32_t sample_rate, OversampleRate oversample_rate = OversampleRate::None);
 void capture_start(CaptureConfig* const config);
 void capture_stop();
 void replay_start(ReplayConfig* const config);
@@ -5607,6 +5607,44 @@ static constexpr Bitmap bitmap_icon_speaker_and_headphones_mute{
    {16, 16},
    bitmap_icon_speaker_and_headphones_mute_data};

+static constexpr uint8_t bitmap_icon_shift_data[] = {
+    0x00,
+    0x00,
+    0x80,
+    0x00,
+    0xC0,
+    0x01,
+    0xE0,
+    0x03,
+    0xF0,
+    0x07,
+    0xF8,
+    0x0F,
+    0xFC,
+    0x1F,
+    0xE0,
+    0x03,
+    0xE0,
+    0x03,
+    0xE0,
+    0x03,
+    0x20,
+    0x02,
+    0xE0,
+    0x03,
+    0x20,
+    0x02,
+    0xE0,
+    0x03,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+static constexpr Bitmap bitmap_icon_shift{
+    {16, 16},
+    bitmap_icon_shift_data};
+
 } /* namespace ui */

 #endif /*__BITMAP_HPP__*/
@@ -568,6 +568,17 @@ bool is_directory(const path& file_path) {
    return fr == FR_OK && is_directory(static_cast<file_status>(filinfo.fattrib));
 }

+bool is_empty_directory(const path& file_path) {
+    DIR dir;
+    FILINFO filinfo;
+
+    if (!is_directory(file_path))
+        return false;
+
+    auto result = f_findfirst(&dir, &filinfo, reinterpret_cast<const TCHAR*>(file_path.c_str()), (const TCHAR*)u"*");
+    return !((result == FR_OK) && (filinfo.fname[0] != (TCHAR)'\0'));
+}
+
 space_info space(const path& p) {
    DWORD free_clusters{0};
    FATFS* fs;
@@ -248,6 +248,7 @@ bool is_directory(const file_status s);
 bool is_regular_file(const file_status s);
 bool file_exists(const path& file_path);
 bool is_directory(const path& file_path);
+bool is_empty_directory(const path& file_path);

 space_info space(const path& p);

@@ -26,6 +26,7 @@
 #include "file.hpp"
 #include "optional.hpp"

+#include <functional>
 #include <memory>
 #include <string_view>

@@ -75,6 +76,8 @@ class BufferWrapper {
    }
    virtual ~BufferWrapper() {}

+    std::function<void(Size, Size)> on_read_progress{};
+
    /* Prevent copies */
    BufferWrapper(const BufferWrapper&) = delete;
    BufferWrapper& operator=(const BufferWrapper&) = delete;
@@ -234,13 +237,23 @@ class BufferWrapper {

        line_count_ = start_line_;
        Offset offset = start_offset_;
+
+        // Report progress every N lines.
+        constexpr auto report_interval = 100u;
        auto result = next_newline(offset);
+        auto next_report = report_interval;

        while (result) {
            ++line_count_;
            if (newlines_.size() < max_newlines)
                newlines_.push_back(*result);
            offset = *result + 1;
+
+            if (on_read_progress && line_count_ > next_report) {
+                on_read_progress(offset, size());
+                next_report = line_count_ + report_interval;
+            }
+
            result = next_newline(offset);
        }
    }
@@ -397,6 +410,9 @@ class BufferWrapper {
        // Number of bytes left to shift.
        Offset remaining = size() - src;
        Offset offset = size();
+        Size report_total = remaining;
+        Size report_interval = report_total / 8;
+        Size next_report = remaining - report_interval;

        while (remaining > 0) {
            offset -= std::min(remaining, buffer_size);
@@ -413,6 +429,11 @@ class BufferWrapper {
                break;

            remaining -= *result;
+
+            if (on_read_progress && remaining <= next_report) {
+                on_read_progress(report_total - remaining, report_total);
+                next_report = remaining > report_interval ? remaining - report_interval : 0;
+            }
        }
    }

@@ -424,6 +445,9 @@ class BufferWrapper {

        char buffer[buffer_size];
        auto offset = src;
+        Size report_total = size();
+        Size report_interval = report_total / 8;
+        Size next_report = offset + report_interval;

        while (true) {
            wrapped_->seek(offset);
@@ -438,6 +462,11 @@ class BufferWrapper {
                break;

            offset += *result;
+
+            if (on_read_progress && offset >= next_report) {
+                on_read_progress(offset, report_total);
+                next_report = offset + report_interval;
+            }
        }

        // Delete the extra bytes at the end of the file.
@@ -463,13 +492,19 @@ class FileWrapper : public BufferWrapper<File, 64> {
    template <typename T>
    using Result = File::Result<T>;
    using Error = File::Error;
-    static Result<std::unique_ptr<FileWrapper>> open(const std::filesystem::path& path, bool create = false) {
+    static Result<std::unique_ptr<FileWrapper>> open(
+        const std::filesystem::path& path,
+        bool create = false,
+        std::function<void(Size, Size)> on_read_progress = nullptr) {
        auto fw = std::unique_ptr<FileWrapper>(new FileWrapper());
        auto error = fw->file_.open(path, /*read_only*/ false, create);

        if (error)
            return *error;

+        if (on_read_progress)
+            fw->on_read_progress = on_read_progress;
+
        fw->initialize();
        return fw;
    }
@@ -74,18 +74,19 @@ options_t freqman_bandwidths[4] = {
    },
    {
        // SPEC -- TODO: these should be indexes.
-        {"8k5", 8500},
-        {"11k", 11000},
+        {"12k5", 12500},
        {"16k", 16000},
+        {"20k", 20000},
        {"25k", 25000},
        {"50k", 50000},
        {"100k", 100000},
        {"250k", 250000},
        {"500k", 500000}, /* Previous Limit bandwith Option with perfect micro SD write .C16 format operaton.*/
-        {"600k", 600000}, /* That extended option is still possible to record with FW version Mayhem v1.41 (< 2,5MB/sec) */
+        {"600k", 600000}, /* We doubled x2 previous REC BW limit , now extended BW from 600k to 1M with fast enough SD card in C16 or C8 format .*/
        {"650k", 650000},
-        {"750k", 750000}, /* From this BW onwards, the LCD is ok, but the recorded file is decimated, (not real file size) */
-        {"1100k", 1100000},
+        {"750k", 750000},
+        {"1000k", 1000000}, /* New limit bandwith option for recording in C16 (in fast SD card) or in C8 */
+        {"1500k", 1500000}, /* From this BW onwards, the LCD is ok, but M4 CPU is having periodical sample rec dropps, (not real file size, accelerated replay) */
        {"1750k", 1750000},
        {"2000k", 2000000},
        {"2500k", 2500000},
@@ -1,5 +1,6 @@
 /*
 * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2023 Mark Thompson
 *
 * This file is part of PortaPack.
 *
@@ -23,86 +24,128 @@

 #include "utility.hpp"

+uint8_t Debounce::state() {
+    bool v = state_to_report_;
+    simulated_pulse_ = false;
+    return v;
+}
+
+void Debounce::enable_repeat() {
+    repeat_enabled_ = true;
+}
+
+bool Debounce::get_long_press_enabled() const {
+    return long_press_enabled_;
+}
+
+void Debounce::set_long_press_enabled(bool v) {
+    long_press_enabled_ = v;
+}
+
+bool Debounce::long_press_occurred() {
+    bool v = long_press_occurred_;
+    long_press_occurred_ = false;
+    return v;
+}
+
 // Returns TRUE if button state changed (after debouncing)
 bool Debounce::feed(const uint8_t bit) {
    history_ = (history_ << 1) | (bit & 1);

-    // "Repeat" handling - simulated button release
-    if (repeat_ctr_) {
-        // Make sure the button is still being held continuously
-        if ((history_ == 0xFF) && !long_press_enabled_) {
-            // Simulate button press every REPEAT_SUBSEQUENT_DELAY ticks
-            if (--repeat_ctr_ == 0) {
-                state_ = !state_;
-                repeat_ctr_ = REPEAT_SUBSEQUENT_DELAY / 2;
-                return true;
-            }
-        } else {
-            // It's a real button release; stop simulating
-            repeat_ctr_ = 0;
-        }
-    }
-
-    if (state_ == 0) {
-        // Previous button state was 0 (released);
-        // Has button been held for DEBOUNCE_COUNT ticks?
-        if ((history_ & DEBOUNCE_MASK) == DEBOUNCE_MASK) {
+    // Has button been held for DEBOUNCE_COUNT ticks?
+    if ((history_ & DEBOUNCE_MASK) == DEBOUNCE_MASK) {
+        //
+        // Button is currently pressed;
+        // Was previous button state 0 (released)?
+        //
+        if (state_ == 0) {
+            //
+            // Button has been pressed (after filtering glitches), transition 0->1
+            //
            state_ = 1;
-            held_time_ = 0;

            // If long_press_enabled_, state() function masks the button press until it's released
            // or until LONG_PRESS_DELAY is reached
            if (long_press_enabled_) {
                pulse_upon_release_ = true;
+                state_to_report_ = 0;
                return false;
            }
+            state_to_report_ = 1;
+            return true;
+        }
+
+        // "Repeat" handling - simulated button release
+        if (repeat_ctr_ && !long_press_enabled_) {
+            // Simulate button press every REPEAT_SUBSEQUENT_DELAY ticks
+            // (by toggling reported state every 1/2 of the delay time)
+            if (--repeat_ctr_ == 0) {
+                state_to_report_ = !state_to_report_;
+                repeat_ctr_ = REPEAT_SUBSEQUENT_DELAY / 2;
+                return true;
+            }
+        }
+
+        // Keep track of how long button has been held
+        held_time_++;
+        if (pulse_upon_release_) {
+            // Button is being held down and long_press support is enabled for this key:
+            // if LONG_PRESS_DELAY is reached then finally report that switch is pressed and set flag
+            // indicating it was a LONG press
+            // (note that repeat_support and long_press support are mutually exclusive)
+            if (held_time_ >= LONG_PRESS_DELAY) {
+                pulse_upon_release_ = false;
+                long_press_occurred_ = true;
+                state_to_report_ = 1;
+                return true;
+            }
+        } else if (repeat_enabled_ && !long_press_enabled_) {
+            // Repeat support -- 4 directional buttons only (unless long_press is enabled)
+            if (held_time_ >= REPEAT_INITIAL_DELAY) {
+                // Delay reached; trigger repeat code on NEXT tick
+                repeat_ctr_ = 1;
+                held_time_ = 0;
+            }
+        }
+    } else if ((history_ & DEBOUNCE_MASK) == 0) {  // Has button been released for at least DEBOUNCE_COUNT ticks?
+        //
+        // Button is released;
+        // Was previous button state 1 (pressed)?
+        //
+        if (state_ == 1) {
+            //
+            // Button has been released (after filtering glitches), transition 1->0
+            //
+            state_ = 0;
+            long_press_occurred_ = false;
+
+            // If button released when long_press_enabled_ and before LONG_PRESS_DELAY was reached;
+            // allow state() function to finally return a single press indication (simulated pulse).
+            // Note: In long press mode, apps won't see button press until the button is released.
+            if (pulse_upon_release_) {
+                pulse_upon_release_ = false;
+                simulated_pulse_ = true;
+                state_to_report_ = 1;
+                return true;
+            }
+
+            state_to_report_ = 0;
+            return true;
+        }
+
+        // Reset reported state after application/event has cleared simulated_pulse_
+        if (state_to_report_ == 1 && !simulated_pulse_) {
+            state_to_report_ = 0;
            return true;
        }
    } else {
-        // Previous button state was 1 (pressed);
-        // Has button been released for DEBOUNCE_COUNT ticks?
-        if ((history_ & DEBOUNCE_MASK) == 0) {
-            // Button has been released when long_press_enabled_ and before LONG_PRESS_DELAY was reached;
-            // allow state() function to finally return a single press indication
-            // (in long press mode, apps won't see button press until the button is released)
-            if (pulse_upon_release_) {
-                // leaving state_==1 for one cycle
-                pulse_upon_release_ = 0;
-            } else {
-                state_ = 0;
-            }
-
-            // Reset long_press_occurred_ flag after button is released
-            long_press_occurred_ = false;
-            return true;
-        }
-
-        // Has button been held continuously?
-        if (history_ == 0xFF) {
-            held_time_++;
-            if (pulse_upon_release_) {
-                // Button is being held down and long_press support is enabled for this key:
-                // if LONG_PRESS_DELAY is reached then finally report that switch is pressed and set flag
-                // indicating it was a LONG press
-                // (note that repease_support and long_press support are mutually exclusive)
-                if (held_time_ == LONG_PRESS_DELAY) {
-                    long_press_occurred_ = true;
-                    pulse_upon_release_ = 0;
-                    held_time_ = 0;
-                    return true;
-                }
-            } else if (repeat_enabled_ && !long_press_enabled_) {
-                // Repeat support -- 4 directional buttons only (unless long_press is enabled)
-                if (held_time_ == REPEAT_INITIAL_DELAY) {
-                    // Delay reached; trigger repeat code on NEXT tick
-                    repeat_ctr_ = 1;
-                    held_time_ = 0;
-                }
-            }
-        } else {
-            // Button not continuously pressed; reset counter
-            held_time_ = 0;
-        }
+        //
+        // Button is in transition between states;
+        // Reset counters until button inputs are stable.
+        //
+        held_time_ = 0;
+        repeat_ctr_ = 0;
    }
+
    return false;
 }
@@ -31,39 +31,37 @@
 // # of timer0 ticks before a held button starts being counted as repeated presses
 #define REPEAT_INITIAL_DELAY 250
 #define REPEAT_SUBSEQUENT_DELAY 92
-#define LONG_PRESS_DELAY 1000
+#define LONG_PRESS_DELAY 800

 class Debounce {
   public:
    bool feed(const uint8_t bit);
-
-    uint8_t state() const {
-        return (pulse_upon_release_) ? 0 : state_;
-    }
-
-    void enable_repeat() {
-        repeat_enabled_ = true;
-    }
-
-    void set_long_press_support(bool v) {
-        long_press_enabled_ = v;
-    }
-
-    bool long_press_occurred() {
-        bool v = long_press_occurred_;
-        long_press_occurred_ = false;
-        return v;
-    }
+    uint8_t state();
+    void enable_repeat();
+    bool get_long_press_enabled() const;
+    void set_long_press_enabled(bool v);
+    bool long_press_occurred();

   private:
-    uint8_t history_{0};
-    uint8_t state_{0};
-    bool repeat_enabled_{0};
-    uint16_t repeat_ctr_{0};
-    uint16_t held_time_{0};
-    bool pulse_upon_release_{0};
-    bool long_press_enabled_{0};
-    bool long_press_occurred_{0};
+    uint8_t history_{0};  // shift register of last 8 reads from button hardware state bit
+
+    uint8_t state_{0};  // actual button hardware state (after debounce logic), 1=pressed
+
+    uint8_t state_to_report_{0};  // pseudo button state reported by state() function (may be masked off or simulated presses)
+
+    bool repeat_enabled_{false};  // TRUE if this button is enabled to auto-repeat when held down (ignored if long_press_enabled)
+
+    uint16_t repeat_ctr_{0};  // used for timing auto-repeat simulated button presses when button is held down and repeat_enabled
+
+    uint16_t held_time_{0};  // number of ticks that the button has been held down (compared against REPEAT and LONG_PRESS delays)
+
+    bool pulse_upon_release_{false};  // TRUE when button is being held down when long_press_enabled and LONG_PRESS_DELAY hasn't been reached yet
+
+    bool simulated_pulse_{false};  // TRUE if a simulated button press is active following a short button press (only when long_press_enabled)
+
+    bool long_press_enabled_{false};  // TRUE when button is in long-press mode (takes precedence over the repeat_enabled flag)
+
+    bool long_press_occurred_{false};  // TRUE when button is being held down and LONG_PRESS_DELAY has been reached (only when long_press_enabled)
 };

 #endif /*__DEBOUNCE_H__*/
@@ -32,24 +32,66 @@
 // 12 degrees of rotation.
 //
 // For each encoder "pulse" there are 4 state transitions, and we can choose
-// how many transitions are needed before movement is registered
-static const int8_t transition_map[16] = {
-    0,   // 0000: noop
-    -1,  // 0001: ccw start
-    1,   // 0010: cw start
-    0,   // 0011: rate
-    1,   // 0100: cw end
-    0,   // 0101: noop
-    0,   // 0110: rate
-    -1,  // 0111: ccw end
-    -1,  // 1000: ccw end
-    0,   // 1001: rate
-    0,   // 1010: noop
-    1,   // 1011: cw end
-    0,   // 1100: rate
-    1,   // 1101: cw start
-    -1,  // 1110: ccw start
-    0,   // 1111: noop
+// between looking at all of them (high sensitivity), half of them (medium/default),
+// or one quarter of them (low sensitivity).
+static const int8_t transition_map[][16] = {
+    // Normal (Medium) Sensitivity -- default
+    {
+        0,   // 0000: noop
+        0,   // 0001: ccw start
+        0,   // 0010: cw start
+        0,   // 0011: rate
+        1,   // 0100: cw end
+        0,   // 0101: noop
+        0,   // 0110: rate
+        -1,  // 0111: ccw end
+        -1,  // 1000: ccw end
+        0,   // 1001: rate
+        0,   // 1010: noop
+        1,   // 1011: cw end
+        0,   // 1100: rate
+        0,   // 1101: cw start
+        0,   // 1110: ccw start
+        0,   // 1111: noop
+    },
+    // Low Sensitivity
+    {
+        0,   // 0000: noop
+        0,   // 0001: ccw start
+        0,   // 0010: cw start
+        0,   // 0011: rate
+        1,   // 0100: cw end
+        0,   // 0101: noop
+        0,   // 0110: rate
+        0,   // 0111: ccw end
+        -1,  // 1000: ccw end
+        0,   // 1001: rate
+        0,   // 1010: noop
+        0,   // 1011: cw end
+        0,   // 1100: rate
+        0,   // 1101: cw start
+        0,   // 1110: ccw start
+        0,   // 1111: noop
+    },
+    // High Sensitivity
+    {
+        0,   // 0000: noop
+        -1,  // 0001: ccw start
+        1,   // 0010: cw start
+        0,   // 0011: rate
+        1,   // 0100: cw end
+        0,   // 0101: noop
+        0,   // 0110: rate
+        -1,  // 0111: ccw end
+        -1,  // 1000: ccw end
+        0,   // 1001: rate
+        0,   // 1010: noop
+        1,   // 1011: cw end
+        0,   // 1100: rate
+        1,   // 1101: cw start
+        -1,  // 1110: ccw start
+        0,   // 1111: noop
+    },
 };

 int_fast8_t Encoder::update(
@@ -60,13 +102,6 @@ int_fast8_t Encoder::update(
    state <<= 1;
    state |= phase_1;

-    int_fast8_t retval = transition_map[state & 0xf];
-
-    transition_count += retval;
-    if (abs(transition_count) > portapack::persistent_memory::config_encoder_dial_sensitivity())
-        transition_count = 0;
-    else
-        retval = 0;
-
-    return retval;
+    // dial sensitivity setting is stored in pmem
+    return transition_map[portapack::persistent_memory::config_encoder_dial_sensitivity()][state & 0xf];
 }
@@ -32,7 +32,6 @@ class Encoder {

   private:
    uint_fast8_t state{0};
-    int_fast8_t transition_count{0};
 };

 #endif /*__ENCODER_H__*/
@@ -22,32 +22,33 @@
 #include "irq_controls.hpp"

 #include "ch.h"
-#include "hal.h"
-
+#include "debounce.hpp"
+#include "encoder.hpp"
 #include "event_m0.hpp"
-
+#include "hal.h"
 #include "touch.hpp"
 #include "touch_adc.hpp"
-#include "encoder.hpp"
-#include "debounce.hpp"
 #include "utility.hpp"

 #include <cstdint>
 #include <array>

 #include "portapack_io.hpp"
-
 #include "hackrf_hal.hpp"
+
 using namespace hackrf::one;
+using namespace portapack;

 static Thread* thread_controls_event = NULL;

-static std::array<Debounce, 8> switch_debounce;
+// Index with the Switch enum.
+static std::array<Debounce, 6> switch_debounce;
+static std::array<Debounce, 2> encoder_debounce;
+
+static_assert(std::size(switch_debounce) == toUType(Switch::Dfu) + 1);

 static Encoder encoder;
-
 static volatile uint32_t encoder_position{0};
-
 static volatile uint32_t touch_phase{0};

 /* TODO: Change how touch scanning works. It produces a decent amount of noise
@@ -60,11 +61,11 @@ static volatile uint32_t touch_phase{0};
 * Noise will only occur when the panel is being touched. Not ideal, but
 * an acceptable improvement.
 */
-static std::array<portapack::IO::TouchPinsConfig, 3> touch_pins_configs{
+static std::array<IO::TouchPinsConfig, 3> touch_pins_configs{
    /* State machine will pause here until touch is detected. */
-    portapack::IO::TouchPinsConfig::SensePressure,
-    portapack::IO::TouchPinsConfig::SenseX,
-    portapack::IO::TouchPinsConfig::SenseY,
+    IO::TouchPinsConfig::SensePressure,
+    IO::TouchPinsConfig::SenseX,
+    IO::TouchPinsConfig::SenseY,
 };

 static touch::Frame temp_frame;
@@ -80,7 +81,7 @@ static bool touch_update() {
    const auto current_phase = touch_pins_configs[touch_phase];

    switch (current_phase) {
-        case portapack::IO::TouchPinsConfig::SensePressure: {
+        case IO::TouchPinsConfig::SensePressure: {
            const auto z1 = samples.xp - samples.xn;
            const auto z2 = samples.yp - samples.yn;
            const auto touch_raw = (z1 > touch::touch_threshold) || (z2 > touch::touch_threshold);
@@ -94,11 +95,11 @@ static bool touch_update() {
            }
        } break;

-        case portapack::IO::TouchPinsConfig::SenseX:
+        case IO::TouchPinsConfig::SenseX:
            temp_frame.x += samples;
            break;

-        case portapack::IO::TouchPinsConfig::SenseY:
+        case IO::TouchPinsConfig::SenseY:
            temp_frame.y += samples;
            break;

@@ -122,25 +123,57 @@ static bool touch_update() {

 static uint8_t switches_raw = 0;

+/* The raw data is not packed in a way that makes looping over it easy.
+ * One option would be an accessor helper (RawSwitch). Another option
+ * is to swizzle the bits into a friendlier order. */
+// /* Type to access the bits in the raw switch data. */
+// struct RawSwitch {
+//     const uint8_t raw_{0};
+
+// uint8_t right() const { return (raw_ >> 0) & 1; }
+// uint8_t left() const { return (raw_ >> 1) & 1; }
+// uint8_t down() const { return (raw_ >> 2) & 1; }
+// uint8_t up() const { return (raw_ >> 3) & 1; }
+// uint8_t select() const { return (raw_ >> 4) & 1; }
+// uint8_t rot_a() const { return (raw_ >> 5) & 1; }
+// uint8_t rot_b() const { return (raw_ >> 6) & 1; }
+// uint8_t dfu() const { return (raw_ >> 7) & 1; }};
+
+static uint8_t swizzle_raw(uint8_t raw) {
+    return (raw & 0x1F) |         // Keep the bottom 5 bits the same.
+           ((raw >> 2) & 0x20) |  // Shift the DFU bit down to bit 6.
+           ((raw << 1) & 0xC0);   // Shift the encoder bits up to be 7 & 8.
+}
+
 static bool switches_update(const uint8_t raw) {
    // TODO: Only fire event on press, not release?
    bool switch_changed = false;
-    for (size_t i = 0; i < switch_debounce.size(); i++) {
-        switch_changed |= switch_debounce[i].feed((raw >> i) & 1);
+
+    for (size_t i = 0; i < switch_debounce.size(); ++i) {
+        uint8_t bit = (raw >> i) & 0x01;
+        switch_changed |= switch_debounce[i].feed(bit);
    }

    return switch_changed;
 }

+static bool encoder_update(const uint8_t raw) {
+    bool encoder_changed = false;
+
+    encoder_changed |= encoder_debounce[0].feed((raw >> 6) & 0x01);
+    encoder_changed |= encoder_debounce[1].feed((raw >> 7) & 0x01);
+
+    return encoder_changed;
+}
+
 static bool encoder_read() {
    const auto delta = encoder.update(
-        switch_debounce[5].state(),
-        switch_debounce[6].state());
+        encoder_debounce[0].state(),
+        encoder_debounce[1].state());

    if (delta != 0) {
        encoder_position += delta;
        return true;
-        ;
    } else {
        return false;
    }
@@ -149,11 +182,13 @@ static bool encoder_read() {
 void timer0_callback(GPTDriver* const) {
    eventmask_t event_mask = 0;
    if (touch_update()) event_mask |= EVT_MASK_TOUCH;
-    switches_raw = portapack::io.io_update(touch_pins_configs[touch_phase]);
-    if (switches_update(switches_raw)) {
+
+    switches_raw = swizzle_raw(io.io_update(touch_pins_configs[touch_phase]));
+    if (switches_update(switches_raw))
        event_mask |= EVT_MASK_SWITCHES;
-        if (encoder_read()) event_mask |= EVT_MASK_ENCODER;
-    }
+
+    if (encoder_update(switches_raw) && encoder_read())
+        event_mask |= EVT_MASK_ENCODER;

    /* Signal event loop */
    if (event_mask) {
@@ -189,37 +224,40 @@ void controls_init() {
    gptStartContinuous(&GPTD1, timer0_match_count);

    // Enable repeat for directional switches only
-    for (size_t i = 0; i < 4; i++)
-        switch_debounce[i].enable_repeat();
+    for (auto i = Switch::Right; i <= Switch::Up; incr(i))
+        switch_debounce[toUType(i)].enable_repeat();
 }

+// Note: Called by event handler or apps, not in ISR, so some presses might be missed during high CPU utilization
 SwitchesState get_switches_state() {
    SwitchesState result;

-    // Right, Left, Down, Up, & Select switches
-    for (size_t i = 0; i < result.size() - 1; i++) {
-        // TODO: Ignore multiple keys at the same time?
+    // TODO: Ignore multiple keys at the same time?
+    for (size_t i = 0; i < result.size(); i++)
        result[i] = switch_debounce[i].state();
-    }

-    // Grab Dfu switch from bit 7 and return in bit 5 so that all switches are grouped together in this 6-bit result
-    result[(size_t)Switch::Dfu] = switch_debounce[7].state();
    return result;
 }

-// Configure which switches support long press (note those switches will not support Repeat function)
-void switches_long_press_enable(SwitchesState switches_long_press_enabled) {
-    // Right, Left, Down, Up, & Select switches
-    for (size_t i = 0; i < switches_long_press_enabled.size() - 1; i++) {
-        switch_debounce[i].set_long_press_support(switches_long_press_enabled[i]);
-    }
+/* Gets the long press enabled state for all the switches. */
+SwitchesState get_switches_long_press_config() {
+    SwitchesState result;

-    // Dfu switch
-    switch_debounce[7].set_long_press_support(switches_long_press_enabled[(size_t)Switch::Dfu]);
+    for (size_t i = 0; i < result.size(); i++)
+        result[i] = switch_debounce[i].get_long_press_enabled();
+
+    return result;
 }

-bool switch_long_press_occurred(size_t v) {
-    return (v == (size_t)Switch::Dfu) ? switch_debounce[7].long_press_occurred() : switch_debounce[v].long_press_occurred();
+/* Configures which switches support long press.
+ * NB: those switches will not support Repeat function. */
+void set_switches_long_press_config(SwitchesState switch_config) {
+    for (size_t i = 0; i < switch_config.size(); i++)
+        switch_debounce[i].set_long_press_enabled(switch_config[i]);
+}
+
+bool switch_is_long_pressed(Switch s) {
+    return switch_debounce[toUType(s)].long_press_occurred();
 }

 EncoderPosition get_encoder_position() {
@@ -28,25 +28,28 @@
 #include "touch.hpp"

 // Must be same values as in ui::KeyEvent
-enum class Switch {
+// TODO: Why not just reuse one or the other?
+enum class Switch : uint8_t {
    Right = 0,
    Left = 1,
    Down = 2,
    Up = 3,
    Sel = 4,
-    Dfu = 5,
+    Dfu = 5
 };

+// Index with the Switch enum.
 using SwitchesState = std::bitset<6>;
-
 using EncoderPosition = uint32_t;

 void controls_init();
 SwitchesState get_switches_state();
 EncoderPosition get_encoder_position();
 touch::Frame get_touch_frame();
-void switches_long_press_enable(SwitchesState v);
-bool switch_long_press_occurred(size_t v);
+
+SwitchesState get_switches_long_press_config();
+void set_switches_long_press_config(SwitchesState switch_config);
+bool switch_is_long_pressed(Switch s);

 namespace control {
 namespace debug {
@@ -80,6 +80,8 @@ uint32_t ReplayThread::run() {
        chThdSleep(100);
    };

+    constexpr size_t block_size = 512;
+
    // While empty buffers fifo is not empty...
    while (!buffers.empty()) {
        prefill_buffer = buffers.get_prefill();
@@ -87,10 +89,10 @@ uint32_t ReplayThread::run() {
        if (prefill_buffer == nullptr) {
            buffers.put_app(prefill_buffer);
        } else {
-            size_t blocks = config.read_size / 512;
+            size_t blocks = config.read_size / block_size;

            for (size_t c = 0; c < blocks; c++) {
-                auto read_result = reader->read(&((uint8_t*)prefill_buffer->data())[c * 512], 512);
+                auto read_result = reader->read(&((uint8_t*)prefill_buffer->data())[c * block_size], block_size);
                if (read_result.is_error()) {
                    return READ_ERROR;
                }
@@ -22,11 +22,10 @@

 #include "ui_alphanum.hpp"

-#include "portapack.hpp"
 #include "hackrf_hal.hpp"
+#include "portapack.hpp"
 #include "portapack_shared_memory.hpp"
-
-#include <algorithm>
+#include "utility.hpp"

 namespace ui {

@@ -38,6 +37,7 @@ AlphanumView::AlphanumView(
    size_t n;

    add_children({
+        &button_shift,
        &labels,
        &field_raw,
        &text_raw_to_char,
@@ -49,6 +49,19 @@ AlphanumView::AlphanumView(
        this->on_button(button);
    };

+    button_shift.set_vertical_center(true);
+    button_shift.on_select = [this]() {
+        incr(shift_mode);
+
+        // Disallow one-time shift in digits/symbols mode
+        if ((mode == 1) && (shift_mode == ShiftMode::Shift))
+            shift_mode = ShiftMode::ShiftLock;
+        else if (shift_mode > ShiftMode::ShiftLock)
+            shift_mode = ShiftMode::None;
+
+        refresh_keys();
+    };
+
    n = 0;
    for (auto& button : buttons) {
        button.id = n;
@@ -56,9 +69,9 @@ AlphanumView::AlphanumView(
            focused_button = button.id;
        };
        button.on_select = button_fn;
-        button.set_parent_rect({static_cast<Coord>((n % 5) * (240 / 5)),
+        button.set_parent_rect({static_cast<Coord>((n % 5) * (screen_width / 5)),
                                static_cast<Coord>((n / 5) * 38 + 24),
-                                240 / 5, 38});
+                                screen_width / 5, 38});
        add_child(&button);
        n++;
    }
@@ -78,38 +91,59 @@ AlphanumView::AlphanumView(
        char_add(field_raw.value());
    };

-    // make text_raw_to_char widget display the char value from field_raw
    field_raw.on_change = [this](auto) {
        text_raw_to_char.set(std::string{static_cast<char>(field_raw.value())});
    };
 }

-void AlphanumView::set_mode(const uint32_t new_mode) {
-    size_t n = 0;
-
-    if (new_mode < 3)
+void AlphanumView::set_mode(uint32_t new_mode, ShiftMode new_shift_mode) {
+    if (new_mode < std::size(key_sets))
        mode = new_mode;
    else
        mode = 0;

-    const char* key_list = key_sets[mode].second;
+    shift_mode = new_shift_mode;
+    refresh_keys();

+    if (mode + 1 < std::size(key_sets))
+        button_mode.set_text(key_sets[mode + 1].name);
+    else
+        button_mode.set_text(key_sets[0].name);
+}
+
+void AlphanumView::refresh_keys() {
+    auto key_list = shift_mode == ShiftMode::None
+                        ? key_sets[mode].normal
+                        : key_sets[mode].shifted;
+
+    size_t n = 0;
    for (auto& button : buttons) {
-        const std::string label{
-            key_list[n]};
-        button.set_text(label);
+        button.set_text(std::string{key_list[n]});
        n++;
    }

-    if (mode < 2)
-        button_mode.set_text(key_sets[mode + 1].first);
-    else
-        button_mode.set_text(key_sets[0].first);
+    switch (shift_mode) {
+        case ShiftMode::None:
+            button_shift.set_color(Color::dark_grey());
+            break;
+        case ShiftMode::Shift:
+            button_shift.set_color(Color::black());
+            break;
+        case ShiftMode::ShiftLock:
+            button_shift.set_color(Color::dark_blue());
+            break;
+    }
 }

 void AlphanumView::on_button(Button& button) {
    const auto c = button.text()[0];
    char_add(c);
+
+    // TODO: Consolidate shift handling.
+    if (shift_mode == ShiftMode::Shift) {
+        shift_mode = ShiftMode::None;
+        refresh_keys();
+    }
 }

 bool AlphanumView::on_encoder(const EncoderEvent delta) {
@@ -29,6 +29,10 @@
 #include "ui_textentry.hpp"
 #include "ui_menu.hpp"

+// TODO: Building this as a custom widget instead of using
+// all the Button controls would save a considerable amount of RAM.
+// The Buttons each have a backing string but these only need one char.
+
 namespace ui {

 class AlphanumView : public TextEntryView {
@@ -43,22 +47,42 @@ class AlphanumView : public TextEntryView {
    bool on_encoder(const EncoderEvent delta) override;

   private:
-    const char* const keys_upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ, ._";
-    const char* const keys_lower = "abcdefghijklmnopqrstuvwxyz, ._";
-    const char* const keys_digit = "0123456789!\"#'()*+-/:;=<>@[\\]?";
+    enum class ShiftMode : uint8_t {
+        None,
+        Shift,
+        ShiftLock,
+    };

-    const std::pair<std::string, const char*> key_sets[3] = {
-        {"ABC", keys_upper},
-        {"abc", keys_lower},
-        {"123", keys_digit}};
+    const char* const keys_lower = "abcdefghijklmnopqrstuvwxyz, .";
+    const char* const keys_upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ, .";
+    const char* const keys_digit = "1234567890()'`\"+-*/=<>_\\!?, .";
+    const char* const keys_symbl = "!@#$%^&*()[]'`\"{}|:;<>-_~?, .";
+
+    struct key_set_t {
+        const char* name;
+        const char* normal;
+        const char* shifted;
+    };
+
+    const key_set_t key_sets[2] = {
+        {"abc", keys_lower, keys_upper},
+        {"123", keys_digit, keys_symbl}};

    int16_t focused_button = 0;
-    uint32_t mode = 0;  // Uppercase
+    uint32_t mode = 0;  // Letters.
+    ShiftMode shift_mode = ShiftMode::None;

-    void set_mode(const uint32_t new_mode);
+    void set_mode(uint32_t new_mode, ShiftMode new_shift_mode = ShiftMode::None);
+    void refresh_keys();
    void on_button(Button& button);

-    std::array<Button, 30> buttons{};
+    std::array<Button, 29> buttons{};
+
+    NewButton button_shift{
+        {192, 214, screen_width / 5, 38},
+        {},
+        &bitmap_icon_shift,
+        Color::dark_grey()};

    Labels labels{
        {{1 * 8, 33 * 8}, "Raw:", Color::light_grey()},
@@ -76,11 +100,11 @@ class AlphanumView : public TextEntryView {
        "0"};

    Button button_delete{
-        {9 * 8, 33 * 8, 6 * 8, 32},
+        {9 * 8, 32 * 8 - 3, 7 * 8, 3 * 16 + 3},
        "<DEL"};

    Button button_mode{
-        {16 * 8, 33 * 8, 5 * 8, 32},
+        {16 * 8, 32 * 8 - 3, 6 * 8, 3 * 16 + 3},
        ""};
 };

@@ -32,6 +32,7 @@ using namespace portapack;
 #include "string_format.hpp"
 #include "complex.hpp"
 #include "ui_styles.hpp"
+#include "ui_font_fixed_5x8.hpp"

 namespace ui {

@@ -243,6 +244,7 @@ void GeoMap::paint(Painter& painter) {

        // Draw the other markers
        draw_markers(painter);
+        draw_scale(painter);
        markerListUpdated = false;
        set_clean();
    }
@@ -283,6 +285,10 @@ void GeoMap::move(const float lon, const float lat) {
        x_pos = map_width - map_rect.width();
    if (y_pos > (map_height + map_rect.height()))
        y_pos = map_height - map_rect.height();
+
+    // Scale calculation
+    float km_per_deg_lon = cos(lat * pi / 180) * 111.321;  // 111.321 km/deg longitude at equator, and 0 km at poles
+    pixels_per_km = (map_rect.width() / 2) / km_per_deg_lon;
 }

 bool GeoMap::init() {
@@ -318,6 +324,24 @@ bool GeoMap::manual_panning() {
    return manual_panning_;
 }

+void GeoMap::draw_scale(Painter& painter) {
+    uint16_t km = 100;
+    uint16_t scale_width = km * pixels_per_km * map_zoom;
+
+    while (scale_width > screen_width / 2) {
+        scale_width /= 2;
+        km /= 2;
+    }
+
+    std::string km_string = to_string_dec_uint(km) + " km";
+
+    display.fill_rectangle({{screen_width - 5 - scale_width, screen_height - 4}, {scale_width, 2}}, Color::black());
+    display.fill_rectangle({{screen_width - 5, screen_height - 8}, {2, 6}}, Color::black());
+    display.fill_rectangle({{screen_width - 5 - scale_width, screen_height - 8}, {2, 6}}, Color::black());
+
+    painter.draw_string({(uint16_t)(screen_width - 25 - scale_width - km_string.length() * 5 / 2), screen_height - 10}, ui::font::fixed_5x8, Color::black(), Color::white(), km_string);
+}
+
 void GeoMap::draw_bearing(const Point origin, const uint16_t angle, uint32_t size, const Color color) {
    Point arrow_a, arrow_b, arrow_c;

@@ -179,6 +179,7 @@ class GeoMap : public Widget {
    MapMarkerStored store_marker(GeoMarker& marker);

   private:
+    void draw_scale(Painter& painter);
    void draw_bearing(const Point origin, const uint16_t angle, uint32_t size, const Color color);
    void draw_marker(Painter& painter, const ui::Point itemPoint, const uint16_t itemAngle, const std::string itemTag, const Color color = Color::red(), const Color fontColor = Color::white(), const Color backColor = Color::black());
    void draw_markers(Painter& painter);
@@ -199,6 +200,7 @@ class GeoMap : public Widget {
    int32_t prev_x_pos{0xFFFF}, prev_y_pos{0xFFFF};
    float lat_{};
    float lon_{};
+    float pixels_per_km{};
    uint16_t angle_{};
    std::string tag_{};

@@ -20,16 +20,15 @@
 * Boston, MA 02110-1301, USA.
 */

+#include "irq_controls.hpp"
+#include "max283x.hpp"
+#include "portapack.hpp"
+#include "string_format.hpp"
 #include "ui_receiver.hpp"
 #include "ui_freqman.hpp"

-#include "portapack.hpp"
 using namespace portapack;

-#include "string_format.hpp"
-
-#include "max283x.hpp"
-
 namespace ui {

 /* FrequencyField ********************************************************/
@@ -38,15 +37,26 @@ FrequencyField::FrequencyField(
    const Point parent_pos)
    : Widget{{parent_pos, {8 * 10, 16}}},
      length_{11},
-      range(rf::tuning_range) {
+      range_{rf::tuning_range} {
+    initial_switch_config_ = get_switches_long_press_config();
    set_focusable(true);
 }

+FrequencyField::~FrequencyField() {
+    reset_switch_config();
+}
+
 rf::Frequency FrequencyField::value() const {
    return value_;
 }

 void FrequencyField::set_value(rf::Frequency new_value) {
+    // While in digit mode, don't update if the value is
+    // out of range. That way going out of range doesn't
+    // cause all the other digits to reset.
+    if (digit_mode_ && !range_.contains_inc(new_value))
+        return;
+
    new_value = clamp_value(new_value);

    if (new_value != value_) {
@@ -59,48 +69,98 @@ void FrequencyField::set_value(rf::Frequency new_value) {
 }

 void FrequencyField::set_step(rf::Frequency new_value) {
-    step = new_value;
    // TODO: Quantize current frequency to a step of the new size?
+    step_ = new_value;
+}
+
+void FrequencyField::set_allow_digit_mode(bool allowed) {
+    allow_digit_mode_ = allowed;
+
+    if (!allowed && digit_mode_) {
+        digit_mode_ = false;
+        reset_switch_config();
+        set_dirty();
+    }
 }

 void FrequencyField::paint(Painter& painter) {
-    const std::string str_value = to_string_short_freq(value_);
-
+    const auto str_value = to_string_short_freq(value_);
    const auto paint_style = has_focus() ? style().invert() : style();

    painter.draw_string(
        screen_pos(),
        paint_style,
        str_value);
+
+    // Highlight current digit in digit_mode.
+    if (digit_mode_) {
+        auto p = screen_pos();
+        p += {digit_ * char_width, 0};
+        painter.draw_char(p, Styles::bg_blue, str_value[digit_]);
+    }
 }

-bool FrequencyField::on_key(const ui::KeyEvent event) {
-    if (event == ui::KeyEvent::Select) {
+bool FrequencyField::on_key(KeyEvent event) {
+    if (event == KeyEvent::Select) {
+        // Toggle 'digit' mode with long-press.
+        if (digit_mode_ || key_is_long_pressed(event)) {
+            digit_mode_ = !digit_mode_;
+            set_dirty();
+            return true;
+        }
+
        if (on_edit) {
            on_edit();
            return true;
        }
    }
+
+    if (digit_mode_) {
+        constexpr uint8_t decimal_pos = 4;
+        int8_t delta = 0;
+
+        switch (event) {
+            case KeyEvent::Up:
+                set_value(value_ + digit_step());
+                break;
+            case KeyEvent::Down:
+                set_value(value_ - digit_step());
+                break;
+            case KeyEvent::Left:
+                delta = -1;
+                break;
+            case KeyEvent::Right:
+                delta = 1;
+                break;
+            default:
+                return false;
+        }
+
+        if (delta != 0) {
+            digit_ += delta;
+
+            // If on decimal, skip it.
+            if (digit_ == decimal_pos)
+                digit_ += delta;
+            // Otherwise ensure in bounds.
+            else
+                digit_ = clip<int8_t>(digit_, 0, 8);
+
+            set_dirty();
+        }
+
+        return true;
+    }
+
    return false;
 }

 bool FrequencyField::on_encoder(const EncoderEvent delta) {
-    if (step == 0) {  // 'Auto' mode.'
-        auto ms = RTT2MS(halGetCounterValue());
-        auto delta_ms = last_ms_ <= ms ? ms - last_ms_ : ms;
-        last_ms_ = ms;
+    if (digit_mode_)
+        set_value(value_ + (delta * digit_step()));
+    else
+        set_value(value_ + (delta * step_));

-        // The goal is to map 'scale' to a range of about 10 to 10M.
-        // The faster the encoder is rotated, the larger the step.
-        // Linear doesn't feel right. Hyperbolic felt better.
-        // To get these magic numbers, I graphed the function until the
-        // curve shape seemed about right then tested on device.
-        delta_ms = std::min(145ull, delta_ms) + 5;  // Prevent DIV/0
-        int64_t scale = 200'000'000 / (0.001'55 * std::pow(delta_ms, 5.45)) + 8;
-        set_value(value() + (delta * scale));
-    } else {
-        set_value(value() + (delta * step));
-    }
    return true;
 }

@@ -112,13 +172,49 @@ bool FrequencyField::on_touch(const TouchEvent event) {
 }

 void FrequencyField::on_focus() {
-    if (on_show_options) {
+    if (on_show_options)
        on_show_options();
-    }
+
+    enable_switch_config();
+}
+
+void FrequencyField::on_blur() {
+    reset_switch_config();
+}
+
+rf::Frequency FrequencyField::digit_step() const {
+    constexpr rf::Frequency steps[] = {
+        1'000'000'000,
+        100'000'000,
+        10'000'000,
+        1'000'000,
+        0,  // Decimal point position.
+        100'000,
+        10'000,
+        1'000,
+        100,
+    };
+
+    return digit_ < std::size(steps) ? steps[digit_] : 0;
 }

 rf::Frequency FrequencyField::clamp_value(rf::Frequency value) {
-    return range.clip(value);
+    return range_.clip(value);
+}
+
+void FrequencyField::enable_switch_config() {
+    // Don't enable long press testing when not allowed.
+    if (!allow_digit_mode_)
+        return;
+
+    // Enable long press on "Select".
+    SwitchesState config;
+    config[toUType(Switch::Sel)] = true;
+    set_switches_long_press_config(config);
+}
+
+void FrequencyField::reset_switch_config() {
+    set_switches_long_press_config(initial_switch_config_);
 }

 /* FrequencyKeypadView ***************************************************/
@@ -27,6 +27,7 @@
 #include "ui_painter.hpp"
 #include "ui_widget.hpp"

+#include "irq_controls.hpp"
 #include "rf_path.hpp"

 #include <cstddef>
@@ -45,27 +46,41 @@ class FrequencyField : public Widget {
    using range_t = rf::FrequencyRange;

    FrequencyField(Point parent_pos);
+    ~FrequencyField();

    rf::Frequency value() const;

    void set_value(rf::Frequency new_value);
    void set_step(rf::Frequency new_value);
+    void set_allow_digit_mode(bool allowed);

    void paint(Painter& painter) override;

-    bool on_key(ui::KeyEvent event) override;
+    bool on_key(KeyEvent event) override;
    bool on_encoder(EncoderEvent delta) override;
    bool on_touch(TouchEvent event) override;
    void on_focus() override;
+    void on_blur() override;

   private:
    const size_t length_;
-    const range_t range;
+    const range_t range_;
+
    rf::Frequency value_{0};
-    rf::Frequency step{25000};
+    rf::Frequency step_{25000};
    uint64_t last_ms_{0};

+    uint8_t digit_{3};
+    bool digit_mode_{false};
+    bool allow_digit_mode_{true};
+    SwitchesState initial_switch_config_{};
+
+    /* Gets the step value for the given digit when in digit_mode. */
+    rf::Frequency digit_step() const;
    rf::Frequency clamp_value(rf::Frequency value);
+
+    void enable_switch_config();
+    void reset_switch_config();
 };

 template <size_t N>
@@ -242,7 +257,6 @@ class FrequencyStepView : public OptionsField {
              parent_pos,
              5,
              {
-                  {" Auto", 0},  /* Faster == larger step. */
                  {"   10", 10}, /* Fine tuning SSB voice pitch,in HF and QO-100 sat #669 */
                  {"   50", 50}, /* added 50Hz/10Hz,but we do not increase GUI digit decimal */
                  {"  100", 100},
@@ -380,33 +380,38 @@ void WaterfallView::on_audio_spectrum() {

 } /* namespace spectrum */

+// TODO: Comments below refer to a fixed oversample rate (8x), cleanup.
 uint32_t filter_bandwidth_for_sampling_rate(int32_t sampling_rate) {
-    switch (sampling_rate) {  // Use the var fs (sampling_rate) to set up BPF aprox < fs_max / 2 by Nyquist theorem.
-        case 0 ... 2000000:   // BW Captured range (0 <= 250kHz max)  fs = 8 x 250 kHz.
-            return 1750000;   // Minimum BPF MAX2837 for all those lower BW options.
+    switch (sampling_rate) {   // Use the var fs (sampling_rate) to set up BPF aprox < fs_max / 2 by Nyquist theorem.
+        case 0 ... 2'000'000:  // BW Captured range (0 <= 250kHz max)  fs = 8 x 250 kHz.
+            return 1'750'000;  // Minimum BPF MAX2837 for all those lower BW options.

-        case 4000000 ... 6000000:  // BW capture range (500k...750kHz max)  fs_max = 8 x 750kHz = 6Mhz
-                                   // BW 500k...750kHz, ex. 500kHz (fs = 8 x BW = 4Mhz), BW 600kHz (fs = 4,8Mhz), BW 750 kHz (fs = 6Mhz).
-            return 2500000;        // In some IC, MAX2837 appears as 2250000, but both work similarly.
+        case 4'000'000 ... 6'000'000:  // BW capture range (500k...750kHz max)  fs_max = 8 x 750kHz = 6Mhz
+                                       // BW 500k...750kHz, ex. 500kHz (fs = 8 x BW = 4Mhz), BW 600kHz (fs = 4,8Mhz), BW 750 kHz (fs = 6Mhz).
+            return 2'500'000;          // In some IC, MAX2837 appears as 2250000, but both work similarly.

-        case 8800000:  // BW capture 1,1Mhz fs = 8 x 1,1Mhz = 8,8Mhz. (1Mhz showed slightly higher noise background).
-            return 3500000;
+        case 8'000'000:        // BW capture 1Mhz fs = 8 x 1Mhz = 8Mhz. (1Mhz showed slightly higher noise background).
+            return 3'500'000;  // some low SD cards, if not showing avg. writting speed >4MB/sec, they will produce sammples drop at REC with 1MB and C16 format.

-        case 14000000:  // BW capture 1,75Mhz, fs = 8 x 1,75Mhz = 14Mhz
-                        // Good BPF, good matching, but LCD flickers, refresh rate should be < 20 Hz, reasonable picture.
-            return 5000000;
+        case 12'000'000:  // BW capture 1,5Mhz, fs = 8 x 1,5Mhz = 12Mhz
+                          // Good BPF, good matching, we have some periodical M4 % samples drop.
+            return 5'000'000;

-        case 16000000:  // BW capture 2Mhz, fs = 8 x 2Mhz = 16Mhz
-                        // Good BPF, good matching, but LCD flickers, refresh rate should be < 20 Hz, reasonable picture.
-            return 6000000;
+        case 14'000'000:  // BW capture 1,75Mhz, fs = 8 x 1,75Mhz = 14Mhz
+                          // Good BPF, good matching, we have some periodical M4 % samples drop.
+            return 5'000'000;

-        case 20000000:  // BW capture 2,5Mhz, fs = 8 x 2,5 Mhz = 20Mhz
-                        // Good BPF, good matching, but LCD flickers, refresh rate should be < 20 Hz, reasonable picture.
-            return 7000000;
+        case 16'000'000:  // BW capture 2Mhz, fs = 8 x 2Mhz = 16Mhz
+                          // Good BPF, good matching, we have some periodical M4 % samples drop.
+            return 6'000'000;
+
+        case 20'000'000:  // BW capture 2,5Mhz, fs = 8 x 2,5 Mhz = 20Mhz
+                          // Good BPF, good matching, we have some periodical M4 % samples drop.
+            return 7'000'000;

        default:  // BW capture 2,75Mhz, fs = 8 x 2,75Mhz = 22Mhz max ADC sampling and others.
                  // We tested also 9Mhz FPB slightly too much noise floor, better at 8Mhz.
-            return 8000000;
+            return 8'000'000;
    }
 }

@@ -21,9 +21,7 @@
 */

 #include "ui_textentry.hpp"
-//#include "portapack_persistent_memory.hpp"
 #include "ui_alphanum.hpp"
-//#include "ui_handwrite.hpp"

 using namespace portapack;

@@ -50,7 +50,7 @@ class TextEntryView : public View {

    TextEdit text_input;
    Button button_ok{
-        {22 * 8, 33 * 8, 7 * 8, 32},
+        {22 * 8, 32 * 8 - 3, 8 * 8, 3 * 16 + 3},
        "OK"};
 };

@@ -30,6 +30,7 @@ using namespace portapack;

 #include "baseband_api.hpp"
 #include "metadata_file.hpp"
+#include "oversample.hpp"
 #include "rtc_time.hpp"
 #include "string_format.hpp"
 #include "utility.hpp"
@@ -101,24 +102,28 @@ void RecordView::focus() {
    button_record.focus();
 }

-void RecordView::set_sampling_rate(const size_t new_sampling_rate) {
-    /* We are changing "REC" icon background to yellow in  BW rec Options >600kHz
-        where we are NOT recording full IQ .C16 files (recorded files are decimated ones).
-        Those decimated recorded files,has not the full IQ  samples .
-        are ok as recorded spectrum indication, but they  should not be used by Replay app.
+uint32_t RecordView::set_sampling_rate(uint32_t new_sampling_rate) {
+    // Determine the oversampling needed (if any) and the actual sampling rate.
+    auto oversample_rate = get_oversample_rate(new_sampling_rate);
+    auto actual_sampling_rate = new_sampling_rate * toUType(oversample_rate);

-        We keep original black  background in all the correct IQ .C16 files BW's Options */
-    if (new_sampling_rate > 4800000) {  // > BW >600kHz  (fs=8*BW), (750kHz ...2750kHz)
+    /* We are changing "REC" icon background to yellow in BW rec Options >1Mhz
+     * > 1Mhz BW options , we are NOT recording full IQ .C16 files (those files has some periodical  missing dropped samples).
+     * Those recorded files, has not the full IQ samples information, looks like decimated in file size.
+     * They are ok as recorded spectrum indication, but they should not be used by Replay app. (the voice speed will be accelerated)
+
+     * We keep original black background in all the correct IQ .C16 files BW's Options. */
+    if (actual_sampling_rate > 8'000'000) {  // Till fw 1.7.4  BW limit yellow REC button  was >500khz, now  BW >1Mhz  (fs=8*BW), (>1Mhz ..2M75)
        button_record.set_background(ui::Color::yellow());
    } else {
        button_record.set_background(ui::Color::black());
    }

-    if (new_sampling_rate != sampling_rate) {
+    if (sampling_rate != new_sampling_rate) {
        stop();

        sampling_rate = new_sampling_rate;
-        baseband::set_sample_rate(sampling_rate);
+        baseband::set_sample_rate(sampling_rate, oversample_rate);

        button_record.hidden(sampling_rate == 0);
        text_record_filename.hidden(sampling_rate == 0);
@@ -128,6 +133,24 @@ void RecordView::set_sampling_rate(const size_t new_sampling_rate) {

        update_status_display();
    }
+
+    return actual_sampling_rate;
+}
+
+OversampleRate RecordView::get_oversample_rate(uint32_t sample_rate) {
+    // No oversampling necessary for baseband audio processors.
+    if (file_type == FileType::WAV)
+        return OversampleRate::None;
+
+    auto rate = ::get_oversample_rate(sample_rate);
+
+    // Currently proc_capture only supports x8 and x16 for decimation.
+    if (rate < OversampleRate::x8)
+        rate = OversampleRate::x8;
+    else if (rate > OversampleRate::x16)
+        rate = OversampleRate::x16;
+
+    return rate;
 }

 // Setter for datetime and frequency filename
@@ -162,12 +185,13 @@ void RecordView::start() {
        rtcGetTime(&RTCD1, &datetime);

        // ISO 8601
-        std::string date_time = to_string_dec_uint(datetime.year(), 4, '0') +
-                                to_string_dec_uint(datetime.month(), 2, '0') +
-                                to_string_dec_uint(datetime.day(), 2, '0') + "T" +
-                                to_string_dec_uint(datetime.hour()) +
-                                to_string_dec_uint(datetime.minute()) +
-                                to_string_dec_uint(datetime.second());
+        std::string date_time =
+            to_string_dec_uint(datetime.year(), 4, '0') +
+            to_string_dec_uint(datetime.month(), 2, '0') +
+            to_string_dec_uint(datetime.day(), 2, '0') + "T" +
+            to_string_dec_uint(datetime.hour()) +
+            to_string_dec_uint(datetime.minute()) +
+            to_string_dec_uint(datetime.second());

        base_path = filename_stem_pattern.string() + "_" + date_time + "_" +
                    trim(to_string_freq(receiver_model.target_frequency())) + "Hz";
@@ -197,10 +221,8 @@ void RecordView::start() {

        case FileType::RawS8:
        case FileType::RawS16: {
-            const auto metadata_file_error =
-                write_metadata_file(get_metadata_path(base_path),
-                                    {receiver_model.target_frequency(), sampling_rate / 8});
-            // Not sure why sample_rate is div. 8, but stored value matches rate settings.
+            const auto metadata_file_error = write_metadata_file(
+                get_metadata_path(base_path), {receiver_model.target_frequency(), sampling_rate});
            if (metadata_file_error.is_valid()) {
                handle_error(metadata_file_error.value());
                return;
@@ -263,13 +285,19 @@ void RecordView::update_status_display() {
        text_record_dropped.set(s);
    }

-    /*if (pitch_rssi_enabled) {
-                button_pitch_rssi.invert_colors();
-        }*/
+    /*
+    if (pitch_rssi_enabled) {
+        button_pitch_rssi.invert_colors();
+    }
+    */

-    if (sampling_rate) {
+    if (sampling_rate > 0) {
        const auto space_info = std::filesystem::space(u"");
-        const uint32_t bytes_per_second = file_type == FileType::WAV ? (sampling_rate * 2) : (sampling_rate / 8 * 4);  // TODO: Why 8/4??
+        // - Audio is 1 int16_t per sample or '2' bytes per sample.
+        // - C8 captures 2 (I,Q) int8_t per sample or '2' bytes per sample.
+        // - C16 captures 2 (I,Q) int16_t per sample or '4' bytes per sample.
+        const auto bytes_per_sample = file_type == FileType::RawS16 ? 4 : 2;
+        const uint32_t bytes_per_second = sampling_rate * bytes_per_sample;
        const uint32_t available_seconds = space_info.free / bytes_per_second;
        const uint32_t seconds = available_seconds % 60;
        const uint32_t available_minutes = available_seconds / 60;
@@ -42,8 +42,7 @@ class RecordView : public View {
    enum FileType {
        RawS8 = 1,
        RawS16 = 2,
-        RawS32 = 3,
-        WAV = 4,
+        WAV = 3,
    };

    RecordView(
@@ -57,7 +56,11 @@ class RecordView : public View {

    void focus() override;

-    void set_sampling_rate(const size_t new_sampling_rate);
+    /* Sets the sampling rate for the baseband.
+     * NB: Do not pre-apply any oversampling. This function will determine
+     * the correct amount of oversampling and return the actual sample rate
+     * that can be used to configure the radio or other UI element. */
+    uint32_t set_sampling_rate(uint32_t new_sampling_rate);

    void set_file_type(const FileType v) { file_type = v; }

@@ -79,6 +82,8 @@ class RecordView : public View {
    void handle_capture_thread_done(const File::Error error);
    void handle_error(const File::Error error);

+    OversampleRate get_oversample_rate(uint32_t sample_rate);
+
    // bool pitch_rssi_enabled = false;

    // Time Stamp
@@ -90,7 +95,7 @@ class RecordView : public View {
    FileType file_type;
    const size_t write_size;
    const size_t buffer_count;
-    size_t sampling_rate{0};
+    uint32_t sampling_rate{0};
    SignalToken signal_token_tick_second{};

    Rectangle rect_background{
@@ -77,8 +77,8 @@ void AudioTXProcessor::on_message(const Message* const message) {
            replay_config(*reinterpret_cast<const ReplayConfigMessage*>(message));
            break;

-        case Message::ID::SamplerateConfig:
-            samplerate_config(*reinterpret_cast<const SamplerateConfigMessage*>(message));
+        case Message::ID::SampleRateConfig:
+            sample_rate_config(*reinterpret_cast<const SampleRateConfigMessage*>(message));
            break;

        case Message::ID::FIFOData:
@@ -108,7 +108,7 @@ void AudioTXProcessor::replay_config(const ReplayConfigMessage& message) {
    }
 }

-void AudioTXProcessor::samplerate_config(const SamplerateConfigMessage& message) {
+void AudioTXProcessor::sample_rate_config(const SampleRateConfigMessage& message) {
    resample_inc = (((uint64_t)message.sample_rate) << 16) / baseband_fs;  // 16.16 fixed point message.sample_rate
 }

@@ -53,7 +53,7 @@ class AudioTXProcessor : public BasebandProcessor {
    bool configured{false};
    uint32_t bytes_read{0};

-    void samplerate_config(const SamplerateConfigMessage& message);
+    void sample_rate_config(const SampleRateConfigMessage& message);
    void audio_config(const AudioTXConfigMessage& message);
    void replay_config(const ReplayConfigMessage& message);

@@ -27,7 +27,10 @@
 #include "utility.hpp"

 CaptureProcessor::CaptureProcessor() {
-    decim_0.configure(taps_200k_decim_0.taps, 33554432);
+    decim_0_4.configure(taps_200k_decim_0.taps, 33554432);           // to be used with decim1 (/2), then total two stages decim (/8)
+    decim_0_8.configure(taps_200k_decim_0.taps, 33554432);           // to be used with decim1 (/2), then total two stages decim (/16)
+    decim_0_8_180k.configure(taps_180k_wfm_decim_0.taps, 33554432);  // to be used alone - no additional decim1 (/2), then total single stage decim (/8)
+
    decim_1.configure(taps_200k_decim_1.taps, 131072);

    channel_spectrum.set_decimation_factor(1);
@@ -36,8 +39,12 @@ CaptureProcessor::CaptureProcessor() {

 void CaptureProcessor::execute(const buffer_c8_t& buffer) {
    /* 2.4576MHz, 2048 samples */
-    const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
-    const auto decim_1_out = decim_1.execute(decim_0_out, dst_buffer);
+    const auto decim_0_out = decim_0_execute(buffer, dst_buffer);  // selectable 3 possible decim_0, (/4.  /8 200k soft transition filter , /8 180k sharp )
+
+    const auto decim_1_out = baseband_fs < 4800'000
+                                 ? decim_1.execute(decim_0_out, dst_buffer)  // < 500khz double decim. stage
+                                 : decim_0_out;                              // > 500khz single decim. stage
+
    const auto& decimator_out = decim_1_out;
    const auto& channel = decimator_out;

@@ -65,8 +72,8 @@ void CaptureProcessor::on_message(const Message* const message) {
            channel_spectrum.on_message(message);
            break;

-        case Message::ID::SamplerateConfig:
-            samplerate_config(*reinterpret_cast<const SamplerateConfigMessage*>(message));
+        case Message::ID::SampleRateConfig:
+            sample_rate_config(*reinterpret_cast<const SampleRateConfigMessage*>(message));
            break;

        case Message::ID::CaptureConfig:
@@ -78,11 +85,16 @@ void CaptureProcessor::on_message(const Message* const message) {
    }
 }

-void CaptureProcessor::samplerate_config(const SamplerateConfigMessage& message) {
-    baseband_fs = message.sample_rate;
+void CaptureProcessor::sample_rate_config(const SampleRateConfigMessage& message) {
+    baseband_fs = message.sample_rate * toUType(message.oversample_rate);
+    oversample_rate = message.oversample_rate;
+
    baseband_thread.set_sampling_rate(baseband_fs);

-    size_t decim_0_output_fs = baseband_fs / decim_0.decimation_factor;
+    auto decim_0_factor = oversample_rate == OversampleRate::x8
+                              ? decim_0_4.decimation_factor
+                              : decim_0_8.decimation_factor;
+    size_t decim_0_output_fs = baseband_fs / decim_0_factor;

    size_t decim_1_input_fs = decim_0_output_fs;
    size_t decim_1_output_fs = decim_1_input_fs / decim_1.decimation_factor;
@@ -103,6 +115,24 @@ void CaptureProcessor::capture_config(const CaptureConfigMessage& message) {
    }
 }

+buffer_c16_t CaptureProcessor::decim_0_execute(const buffer_c8_t& src, const buffer_c16_t& dst) {
+    switch (oversample_rate) {
+        case OversampleRate::x8:                     // we can get /8 by two means , decim0 (:4) + decim1 (:2) .  or just decim0 (;8)
+            if (baseband_fs < 4800'000) {            // 600khz (600k x 8)
+                return decim_0_4.execute(src, dst);  // decim_0  /4 with double decim stage
+            } else {
+                return decim_0_8_180k.execute(src, dst);  // decim_0  /8 with single decim stage
+            }
+
+        case OversampleRate::x16:
+            return decim_0_8.execute(src, dst);
+
+        default:
+            chDbgPanic("Unhandled OversampleRate");
+            return {};
+    }
+}
+
 int main() {
    EventDispatcher event_dispatcher{std::make_unique<CaptureProcessor>()};
    event_dispatcher.run();
@@ -42,7 +42,7 @@ class CaptureProcessor : public BasebandProcessor {
    void on_message(const Message* const message) override;

   private:
-    size_t baseband_fs = 3072000;
+    size_t baseband_fs = 3072000;  // aka: sample_rate
    static constexpr auto spectrum_rate_hz = 50.0f;

    std::array<complex16_t, 512> dst{};
@@ -50,8 +50,15 @@ class CaptureProcessor : public BasebandProcessor {
        dst.data(),
        dst.size()};

-    dsp::decimate::FIRC8xR16x24FS4Decim4 decim_0{};
+    /* NB: There are two decimation passes: 0 and 1. In pass 0, one of
+     * the following will be selected based on the oversample rate.
+     * use decim_0_4 for an overall decimation factor of 8.
+     * use decim_0_8 for an overall decimation factor of 16. */
+    dsp::decimate::FIRC8xR16x24FS4Decim4 decim_0_4{};
+    dsp::decimate::FIRC8xR16x24FS4Decim8 decim_0_8{};
+    dsp::decimate::FIRC8xR16x24FS4Decim8 decim_0_8_180k{};
    dsp::decimate::FIRC16xR16x16Decim2 decim_1{};
+
    int32_t channel_filter_low_f = 0;
    int32_t channel_filter_high_f = 0;
    int32_t channel_filter_transition = 0;
@@ -61,14 +68,18 @@ class CaptureProcessor : public BasebandProcessor {
    SpectrumCollector channel_spectrum{};
    size_t spectrum_interval_samples = 0;
    size_t spectrum_samples = 0;
+    OversampleRate oversample_rate{OversampleRate::x8};

    /* NB: Threads should be the last members in the class definition. */
    BasebandThread baseband_thread{
        baseband_fs, this, baseband::Direction::Receive, /*auto_start*/ false};
    RSSIThread rssi_thread{};

-    void samplerate_config(const SamplerateConfigMessage& message);
+    void sample_rate_config(const SampleRateConfigMessage& message);
    void capture_config(const CaptureConfigMessage& message);
+
+    /* Dispatch to the correct decim_0 based on oversample rate. */
+    buffer_c16_t decim_0_execute(const buffer_c8_t& src, const buffer_c16_t& dst);
 };

 #endif /*__PROC_CAPTURE_HPP__*/
@@ -83,8 +83,8 @@ void GPSReplayProcessor::on_message(const Message* const message) {
            channel_spectrum.on_message(message);
            break;

-        case Message::ID::SamplerateConfig:
-            samplerate_config(*reinterpret_cast<const SamplerateConfigMessage*>(message));
+        case Message::ID::SampleRateConfig:
+            sample_rate_config(*reinterpret_cast<const SampleRateConfigMessage*>(message));
            break;

        case Message::ID::ReplayConfig:
@@ -103,7 +103,7 @@ void GPSReplayProcessor::on_message(const Message* const message) {
    }
 }

-void GPSReplayProcessor::samplerate_config(const SamplerateConfigMessage& message) {
+void GPSReplayProcessor::sample_rate_config(const SampleRateConfigMessage& message) {
    baseband_fs = message.sample_rate;
    baseband_thread.set_sampling_rate(baseband_fs);
    spectrum_interval_samples = baseband_fs / spectrum_rate_hz;
@@ -64,7 +64,7 @@ class GPSReplayProcessor : public BasebandProcessor {
    bool configured{false};
    uint32_t bytes_read{0};

-    void samplerate_config(const SamplerateConfigMessage& message);
+    void sample_rate_config(const SampleRateConfigMessage& message);
    void replay_config(const ReplayConfigMessage& message);

    TXProgressMessage txprogress_message{};
@@ -41,41 +41,75 @@ ReplayProcessor::ReplayProcessor() {
    baseband_thread.start();
 }

-void ReplayProcessor::execute(const buffer_c8_t& buffer) {
-    /* 4MHz, 2048 samples */
+// Change to 1 to enable buffer assertions in replay.
+#define BUFFER_SIZE_ASSERT 0

+void ReplayProcessor::execute(const buffer_c8_t& buffer) {
    if (!configured || !stream) return;

-    // File data is in C16 format, we need C8
-    // File samplerate is 500kHz, we're at 4MHz
-    // iq_buffer can only be 512 C16 samples (RAM limitation)
-    // To fill up the 2048-sample C8 buffer, we need:
-    // 2048 samples * 2 bytes per sample = 4096 bytes
-    // Since we're oversampling by 4M/500k = 8, we only need 2048/8 = 256 samples from the file and duplicate them 8 times each
-    // So 256 * 4 bytes per sample (C16) = 1024 bytes from the file
-    const size_t bytes_to_read = sizeof(*buffer.p) * 2 * (buffer.count / 8);  // *2 (C16), /8 (oversampling) should be == 1024
-    size_t bytes_read_this_iteration = stream->read(iq_buffer.p, bytes_to_read);
-    size_t oversamples_this_iteration = bytes_read_this_iteration * 8 / (sizeof(*buffer.p) * 2);
+    // Because this is actually adding samples, alias
+    // oversample_rate so the math below is more clear.
+    const size_t interpolation_factor = toUType(oversample_rate);

-    bytes_read += bytes_read_this_iteration;
+    // Wrap the IQ data array in a buffer with the correct sample_rate.
+    buffer_c16_t iq_buffer{iq.data(), iq.size(), baseband_fs / interpolation_factor};

-    // Fill and "stretch"
-    for (size_t i = 0; i < oversamples_this_iteration; i++) {
-        if (i & 7) {
-            buffer.p[i] = buffer.p[i - 1];
-        } else {
-            auto re_out = iq_buffer.p[i >> 3].real() >> 8;
-            auto im_out = iq_buffer.p[i >> 3].imag() >> 8;
-            buffer.p[i] = {(int8_t)re_out, (int8_t)im_out};
+    // The IQ data in stream is C16 format and needs to be converted to C8 (N * 2).
+    // The data also needs to be interpolated so the effective sample rate is closer
+    // to 4Mhz. Because interpolation repeats a sample multiple times, fewer bytes
+    // are needed from the source stream in order to fill the buffer (count / oversample).
+    // Together the C16->C8 conversion and the interpolation give the number of
+    // bytes that need to be read from the source stream.
+    const size_t samples_to_read = buffer.count / interpolation_factor;
+    const size_t bytes_to_read = samples_to_read * sizeof(buffer_c16_t::Type);
+
+#if BUFFER_SIZE_ASSERT
+    // Verify the output buffer size is divisible by the interpolation factor.
+    if (samples_to_read * interpolation_factor != buffer.count)
+        chDbgPanic("Output not div.");
+
+    // Is the input smaple buffer big enough?
+    if (samples_to_read > iq_buffer.size())
+        chDbgPanic("IQ buf ovf.");
+#endif
+
+    // Read the C16 IQ data from the source stream.
+    size_t current_bytes_read = stream->read(iq_buffer.p, bytes_to_read);
+
+    // Compute the number of samples were actually read from the source.
+    size_t samples_read = current_bytes_read / sizeof(buffer_c16_t::Type);
+
+    // Write converted source samples to the output buffer with interpolation.
+    for (auto i = 0u; i < samples_read; ++i) {
+        int8_t re_out = iq_buffer.p[i].real() >> 8;
+        int8_t im_out = iq_buffer.p[i].imag() >> 8;
+        auto out_value = buffer_c8_t::Type{re_out, im_out};
+
+        // Interpolate sample.
+        for (auto j = 0u; j < interpolation_factor; ++j) {
+            size_t index = i * interpolation_factor + j;
+            buffer.p[index] = out_value;
+
+#if BUFFER_SIZE_ASSERT
+            // Verify the index is within bounds.
+            if (index >= buffer.count)
+                chDbgPanic("Output bounds");
+#endif
        }
    }

-    spectrum_samples += oversamples_this_iteration;
+    // Update tracking stats.
+    bytes_read += current_bytes_read;
+    spectrum_samples += samples_read * interpolation_factor;
+
    if (spectrum_samples >= spectrum_interval_samples) {
        spectrum_samples -= spectrum_interval_samples;
-        channel_spectrum.feed(iq_buffer, channel_filter_low_f, channel_filter_high_f, channel_filter_transition);
+        channel_spectrum.feed(
+            iq_buffer, channel_filter_low_f,
+            channel_filter_high_f, channel_filter_transition);

-        txprogress_message.progress = bytes_read;  // Inform UI about progress
+        // Inform UI about progress.
+        txprogress_message.progress = bytes_read;
        txprogress_message.done = false;
        shared_memory.application_queue.push(txprogress_message);
    }
@@ -88,8 +122,8 @@ void ReplayProcessor::on_message(const Message* const message) {
            channel_spectrum.on_message(message);
            break;

-        case Message::ID::SamplerateConfig:
-            samplerate_config(*reinterpret_cast<const SamplerateConfigMessage*>(message));
+        case Message::ID::SampleRateConfig:
+            sample_rate_config(*reinterpret_cast<const SampleRateConfigMessage*>(message));
            break;

        case Message::ID::ReplayConfig:
@@ -108,9 +142,11 @@ void ReplayProcessor::on_message(const Message* const message) {
    }
 }

-void ReplayProcessor::samplerate_config(const SamplerateConfigMessage& message) {
-    baseband_fs = message.sample_rate;
+void ReplayProcessor::sample_rate_config(const SampleRateConfigMessage& message) {
+    baseband_fs = message.sample_rate * toUType(message.oversample_rate);
+    oversample_rate = message.oversample_rate;
    baseband_thread.set_sampling_rate(baseband_fs);
+
    spectrum_interval_samples = baseband_fs / spectrum_rate_hz;
 }

@@ -44,11 +44,8 @@ class ReplayProcessor : public BasebandProcessor {
    size_t baseband_fs = 3072000;
    static constexpr auto spectrum_rate_hz = 50.0f;

+    // Holds the read IQ data chunk from the file to send.
    std::array<complex16_t, 256> iq{};
-    const buffer_c16_t iq_buffer{
-        iq.data(),
-        iq.size(),
-        baseband_fs / 8};

    int32_t channel_filter_low_f = 0;
    int32_t channel_filter_high_f = 0;
@@ -62,8 +59,9 @@ class ReplayProcessor : public BasebandProcessor {

    bool configured{false};
    uint32_t bytes_read{0};
+    OversampleRate oversample_rate = OversampleRate::x8;

-    void samplerate_config(const SamplerateConfigMessage& message);
+    void sample_rate_config(const SampleRateConfigMessage& message);
    void replay_config(const ReplayConfigMessage& message);

    TXProgressMessage txprogress_message{};
@@ -49,6 +49,7 @@ using Timestamp = lpc43xx::rtc::RTC;

 template <typename T>
 struct buffer_t {
+    using Type = T;
    T* const p;
    const size_t count;
    const uint32_t sampling_rate;
@@ -456,6 +456,9 @@ bool ILI9341::drawBMP2(const ui::Point p, const std::filesystem::path& file) {
    width = bmp_header.width;
    height = bmp_header.height;

+    if (width != 240)
+        return false;
+
    file_pos = bmp_header.image_data;

    py = height + 16;
@@ -100,6 +100,9 @@ class ILI9341 {
    constexpr ui::Dim height() const { return 320; }
    constexpr ui::Rect screen_rect() const { return {0, 0, width(), height()}; }

+    void draw_pixels(const ui::Rect r, const ui::Color* const colors, const size_t count);
+    void read_pixels(const ui::Rect r, ui::ColorRGB888* const colors, const size_t count);
+
   private:
    struct scroll_t {
        ui::Coord top_area;
@@ -109,9 +112,6 @@ class ILI9341 {
    };

    scroll_t scroll_state;
-
-    void draw_pixels(const ui::Rect r, const ui::Color* const colors, const size_t count);
-    void read_pixels(const ui::Rect r, ui::ColorRGB888* const colors, const size_t count);
 };

 } /* namespace lcd */
@@ -78,7 +78,7 @@ class Message {
        ReplayThreadDone = 21,
        AFSKRxConfigure = 22,
        StatusRefresh = 23,
-        SamplerateConfig = 24,
+        SampleRateConfig = 24,
        BTLERxConfigure = 25,
        NRFRxConfigure = 26,
        TXProgress = 27,
@@ -798,15 +798,37 @@ class RetuneMessage : public Message {
    uint32_t range = 0;
 };

-class SamplerateConfigMessage : public Message {
+/* Oversample/Interpolation sample rate multipliers. */
+enum class OversampleRate : uint8_t {
+    /* Use either to indicate there's no oversampling needed. */
+    None = 1,
+    x1 = None,
+
+    // 4x would make sense to have, but need to ensure it doesn't
+    // overrun the IQ read buffer in proc_replay.
+
+    /* Oversample rate of 8 times the sample rate. */
+    x8 = 8,
+
+    /* Oversample rate of 16 times the sample rate. */
+    x16 = 16,
+
+    /* Oversample rate of 32 times the sample rate. */
+    x32 = 32,
+};
+
+class SampleRateConfigMessage : public Message {
   public:
-    constexpr SamplerateConfigMessage(
-        const uint32_t sample_rate)
-        : Message{ID::SamplerateConfig},
-          sample_rate(sample_rate) {
+    constexpr SampleRateConfigMessage(
+        uint32_t sample_rate,
+        OversampleRate oversample_rate)
+        : Message{ID::SampleRateConfig},
+          sample_rate(sample_rate),
+          oversample_rate(oversample_rate) {
    }

    const uint32_t sample_rate = 0;
+    const OversampleRate oversample_rate = OversampleRate::None;
 };

 class AudioLevelReportMessage : public Message {
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 Kyle Reed, zxkmm
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+/* Helpers for handling oversampling and interpolation. */
+
+#ifndef __OVERSAMPLE_H__
+#define __OVERSAMPLE_H__
+
+#include "message.hpp"
+#include "utility.hpp"
+
+/* TODO:
+ * The decision to oversample/interpolate should only be a baseband concern.
+ * However, the baseband can't set up the radio (M0 code), so the apps also
+ * need to know about the "actual" sample rate so the radio settings can be
+ * applied correctly. Ideally the baseband would tell the apps what the
+ * actual sample rate is. Currently the apps are telling the baseband and
+ * that feels like a separation of concerns problem. */
+
+/* HackRF suggests a minimum sample rate of 2M so a oversample rate is applied
+ * to the sample rate (pre-scale) to get the sample rate closer to that target.
+ * The baseband needs to know how to correctly decimate (or interpolate) so
+ * the set of allowed scalars is fixed (See OversampleRate enum).
+ * In testing, a minimum rate of 400kHz seems to the functional minimum.
+ */
+
+/* Gets the oversample rate for a given sample rate.
+ * The oversample rate is used to increase the sample rate to improve SNR and quality.
+ * This is also used as the interpolation rate when replaying captures. */
+inline OversampleRate get_oversample_rate(uint32_t sample_rate) {
+    if (sample_rate < 25'000) return OversampleRate::x32;
+    if (sample_rate < 50'000) return OversampleRate::x16;
+
+    return OversampleRate::x8;
+}
+
+/* Gets the actual sample rate for a given sample rate.
+ * This is the rate with the correct oversampling rate applied. */
+inline uint32_t get_actual_sample_rate(uint32_t sample_rate) {
+    return sample_rate * toUType(get_oversample_rate(sample_rate));
+}
+
+#endif /*__OVERSAMPLE_H__*/
@@ -80,7 +80,7 @@ constexpr clkout_freq_range_t clkout_freq_range{10, 60000};
 constexpr uint16_t clkout_freq_reset_value{10000};

 enum data_structure_version_enum : uint32_t {
-    VERSION_CURRENT = 0x10000004,
+    VERSION_CURRENT = 0x10000005,
 };

 static const uint32_t TOUCH_CALIBRATION_MAGIC = 0x074af82f;
@@ -107,11 +107,9 @@ struct backlight_config_t {
 };

 enum encoder_dial_sensitivity {
-    DIAL_SENSITIVITY_HIGHEST = 0,
-    DIAL_SENSITIVITY_HIGH = 1,
-    DIAL_SENSITIVITY_NORMAL = 2,
-    DIAL_SENSITIVITY_LOW = 3,
-    DIAL_SENSITIVITY_LOWEST = 4,
+    DIAL_SENSITIVITY_NORMAL = 0,
+    DIAL_SENSITIVITY_LOW = 1,
+    DIAL_SENSITIVITY_HIGH = 2,
    NUM_DIAL_SENSITIVITY
 };

@@ -20,6 +20,7 @@
 */

 #include "ui.hpp"
+#include "irq_controls.hpp"
 #include "sine_table.hpp"
 #include "utility.hpp"

@@ -102,4 +103,14 @@ Point fast_polar_to_point(int32_t angle, uint32_t distance) {
                 (int16_sin_s4(((1 << 16) * (-angle - 90)) / 360) * distance) / (1 << 16));
 }

+bool key_is_long_pressed(KeyEvent key) {
+    if (key < KeyEvent::Back) {
+        // TODO: this would make more sense as a flag on KeyEvent
+        // passed up to the UI via event dispatch.
+        return switch_is_long_pressed(static_cast<Switch>(key));
+    }
+
+    return false;
+}
+
 } /* namespace ui */
@@ -34,6 +34,10 @@ using Dim = int16_t;
 constexpr uint16_t screen_width = 240;
 constexpr uint16_t screen_height = 320;

+/* Dimensions for the default font character. */
+constexpr uint16_t char_width = 8;
+constexpr uint16_t char_height = 16;
+
 struct Color {
    uint16_t v;  // rrrrrGGGGGGbbbbb

@@ -328,7 +332,7 @@ struct Bitmap {
    const uint8_t* const data;
 };

-enum class KeyEvent {
+enum class KeyEvent : uint8_t {
    /* Ordinals map to bit positions reported by CPLD */
    Right = 0,
    Left = 1,
@@ -356,6 +360,11 @@ Point polar_to_point(float angle, uint32_t distance);

 Point fast_polar_to_point(int32_t angle, uint32_t distance);

+/* Default font glyph size. */
+constexpr Size char_size{char_width, char_height};
+
+bool key_is_long_pressed(KeyEvent key);
+
 } /* namespace ui */

 #endif /*__UI_H__*/
@@ -1188,7 +1188,7 @@ void NewButton::paint(Painter& painter) {
        painter.draw_bitmap(
            bmp_pos,
            *bitmap_,
-            color_,  // Color::green(), //fg,
+            color_,
            bg);
    }

@@ -1667,8 +1667,6 @@ void TextEdit::char_delete() {
 }

 void TextEdit::paint(Painter& painter) {
-    constexpr int char_width = 8;
-
    auto rect = screen_rect();
    auto text_style = has_focus() ? style().invert() : style();
    auto offset = 0;
@@ -1677,15 +1675,14 @@ void TextEdit::paint(Painter& painter) {
    if (cursor_pos_ >= char_count_)
        offset = cursor_pos_ - char_count_ + 1;

-    // Clear the control.
-    painter.fill_rectangle(rect, text_style.background);
-
    // Draw the text starting at the offset.
-    for (uint32_t i = 0; i < char_count_ && i + offset < text_.length(); i++) {
+    for (uint32_t i = 0; i < char_count_; i++) {
+        // Using draw_char to blank the rest of the line with spaces produces less flicker.
+        auto c = (i + offset < text_.length()) ? text_[i + offset] : ' ';
+
        painter.draw_char(
            {rect.location().x() + (static_cast<int>(i) * char_width), rect.location().y()},
-            text_style,
-            text_[i + offset]);
+            text_style, c);
    }

    // Determine cursor position on screen (either the cursor position or the last char).
@@ -1698,7 +1695,7 @@ void TextEdit::paint(Painter& painter) {
        painter.draw_char(cursor_point, cursor_style, text_[cursor_pos_]);

    // Draw the cursor.
-    Rect cursor_box{cursor_point, {char_width, 16}};
+    Rect cursor_box{cursor_point, {char_width, char_height}};
    painter.draw_rectangle(cursor_box, cursor_style.background);
 }

@@ -53,6 +53,12 @@ constexpr typename std::underlying_type<E>::type toUType(E enumerator) noexcept
    return static_cast<typename std::underlying_type<E>::type>(enumerator);
 }

+/* Increments an enum value. Enumerator values are assumed to be serial. */
+template <typename E>
+void incr(E& e) {
+    e = static_cast<E>(toUType(e) + 1);
+}
+
 inline uint32_t flp2(uint32_t v) {
    v |= v >> 1;
    v |= v >> 2;
@@ -180,13 +186,18 @@ struct range_t {
        return value < minimum;
    }

+    /* Exclusive of maximum. */
    constexpr bool contains(const T& value) const {
-        // TODO: Subtle gotcha here! Range test doesn't include maximum!
        return (value >= minimum) && (value < maximum);
    }

+    /* Inclusive of maximum. */
+    constexpr bool contains_inc(const T& value) const {
+        return (value >= minimum) && (value <= maximum);
+    }
+
+    /* Exclusive of maximum. */
    constexpr bool out_of_range(const T& value) const {
-        // TODO: Subtle gotcha here! Range test in contains() doesn't include maximum!
        return !contains(value);
    }
 };
@@ -435,4 +435,29 @@ SCENARIO("Delete line.") {
    }
 }

+SCENARIO("It calls on_read_progress while reading.") {
+    GIVEN("A file larger than internal buffer_size (512)") {
+        std::string content = std::string(599, 'a');
+        content.push_back('x');
+        MockFile f{content};
+
+        auto w = wrap_buffer(f);
+        auto init_line_count = w.line_count();
+        auto init_size = w.size();
+        auto called = false;
+
+        w.on_read_progress = [&called](auto, auto) {
+            called = true;
+        };
+
+        WHEN("Replacing range with larger size") {
+            w.replace_range({0, 2}, "bbb");
+
+            THEN("callback should be called.") {
+                CHECK(called);
+            }
+        }
+    }
+}
+
 TEST_SUITE_END();
Author	SHA1	Message	Date
Brumi-2021	cb0a4854f5	Increase REC BW Option till 1Mhz Capture App (#1352 ) * Increase REC BW Option till 1Mhz Capture App * Format issues * miss type correction * format issues	2023-08-06 21:54:24 +02:00
Mark Thompson	1188157a3e	Reject bmp images that aren't 240 pixels wide (#1351 )	2023-08-05 17:14:18 +02:00
gullradriel	2ae639412d	fix/simplify internal timing (#1348 ) * fix/simplify internal timing	2023-08-04 07:56:39 +02:00
Kyle Reed	37386c29cb	Oversample (#1336 ) * WIP Oversample cleanup * WIP * WIP * WIP dynamic interpolation * WIP cleanup * Fix math errors * Add some optional assertions * Add support for x32 interpolation * Update proc_replay.cpp Typo	2023-08-02 21:59:26 +02:00
jLynx	e2ad0a1b1a	Stable 1.7.4 release (#1340 ) * Update version.txt * Update past_version.txt	2023-08-02 10:24:23 +12:00
Mark Thompson	96cdb2e9e0	Keyboard tweaks (#1338 ) * Disallow 1-time shift in digits/symbols mode * Slightly wider "123" button and smaller OK button * Slightly wider "123" button and smaller OK button	2023-08-01 14:25:26 -05:00
Mark Thompson	002ef720ee	Fixed waterfall frequency scale in Replay app (#1337 ) * Fix waterfall frequency scale in Replay * Fix waterfall frequency scale in Replay	2023-08-01 20:20:19 +02:00
Kyle Reed	2214533894	Keyboard Shift Mode (#1333 ) * Add "shift" concept to keyboard * Better shift colors * Better keybaord layout for symbols * Start ShiftLocked for consistency with previous UX. * Fix number layout * PR and test-drive feedback	2023-07-31 21:44:05 -07:00
Mark Thompson	06b7a0419e	Fixed Select button responsiveness when updating frequency field during heavy CPU activity (e.g. WFM Audio) (#1335 ) * Resolve button responsiveness * Resolve button responsiveness * Clang * Clang * Clang try again * Removed unnecessary lines * Address review comments * Add comments per reviewer suggestion * Clang test * Clang retry	2023-07-31 23:27:15 -05:00
Kyle Reed	d24ff7b3bc	Oversample capturing for low bandwidths (#1332 ) * draft_low_bit_rate_solution_Capture_App * second_draft_dynamic_decim * Add support for Oversample Rate to capture. --------- Co-authored-by: Brumi-2021 <ea3hqj@gmail.com>	2023-07-31 17:46:07 +02:00
Mark Thompson	a24b3ad3de	Correct estimated capture time in C8 format (#1330 ) * Correct capture time remaining for C8 format * Removed unsupported RawS32 type * Clang	2023-07-31 08:02:11 -07:00
Mark Thompson	91c6e3fc30	Display error message when trying to delete non-empty directory (#1321 ) * Non-empty directory check * Non-empty directory check * Display error when attempting to delete non-empty directory * Clang Delete white-space that the friggin editor added * is_empty_directory * is_empty_directory * is_empty_directory * Now need to check if it's a directory first	2023-07-30 15:46:59 -05:00
Kyle Reed	411f6c0a34	Progress bar for Notepad IO (#1322 )	2023-07-30 09:36:57 +02:00
Kyle Reed	0a3aa706ef	Scanner cleanup (#1320 ) * FreqmanDB in Scanner * Format * Add comment on squelch(0)	2023-07-29 15:36:00 -07:00
Kyle Reed	5ca74db2f9	Fix output file config in recon (#1319 )	2023-07-29 07:16:49 +02:00
Kyle Reed	f24523c2f1	Add button to prompt rename with a timestamp. (#1315 )	2023-07-28 18:53:16 -07:00
Mark Thompson	e7c5a862da	Revert encoder sensitivity change (#1314 )	2023-07-27 16:45:39 +02:00
Mark Thompson	b27c738b69	XOR cursor support in Notepad (#1311 ) * XOR cursor support in Notepad * XOR cursor support * XOR cursor support * Revert change * Use static buffer * Use static buffer * Clang	2023-07-27 09:14:02 -05:00
jLynx	8c565bbf15	Allow changelog to run without a token (#1312 ) * Allow code to run without a token * Reverted submodule change by mistake	2023-07-27 14:53:56 +12:00
Mark Thompson	37aa9c046f	Gps default frequency (#1309 ) * Default frequency * Default frequency * Use sample rate from .ini file if present * Eliminate unneeded sampling_rate variable * Eliminate unneeded sampling_rate variable	2023-07-26 13:52:27 -05:00
Kyle Reed	195a6224a0	Freq field tweaks (#1306 ) * UX improvements * Prevent wrapping	2023-07-25 08:06:13 -05:00
Mark Thompson	ea238f4988	Improve Select button response when Long Press is enabled during CPU-intensive apps (WFM) (#1304 ) * Long press * Long-press improvement during CPU-intensive apps * Long-press improvement during CPU-intensive apps	2023-07-24 20:45:24 -07:00
Kyle Reed	3514a9a608	Digit Mode for frequency field (#1298 ) * Remove 'auto' step mode * Support per-digit edits on the freq field. * Swizzle instead of raw accessor * Fix debug ui after swizzle	2023-07-24 18:09:22 +02:00
Mark Thompson	e2bca9aebb	Restore missing line (#1302 )	2023-07-24 10:12:35 -05:00
Mark Thompson	6ae164e59b	Show scale on map (#1296 ) * Add scale to geomap * Add scale to geomap	2023-07-24 14:52:30 +02:00