Recon: Only update manual field if current entry is a range (#1387 )

First pass at custom app-settings support (#1381 )
* First draft of custom app settings support. * WIP new settings * Working per-app custom settings * Revert design to use "bound settings"
2026-09-14 02:29:29 +00:00 · 2023-08-18 22:05:28 +02:00 · 2023-08-18 12:35:41 -07:00 · 2023-08-18 14:49:22 +02:00 · 2023-08-17 17:28:12 +02:00 · 2023-08-17 00:45:24 +02:00
51 changed files with 1037 additions and 360 deletions
@@ -1 +1 @@
-v1.7.2
+v1.7.3
@@ -1 +1 @@
-v1.7.3
+v1.7.4
@@ -23,7 +23,9 @@

 #include "app_settings.hpp"

+#include "convert.hpp"
 #include "file.hpp"
+#include "file_reader.hpp"
 #include "portapack.hpp"
 #include "portapack_persistent_memory.hpp"
 #include "utility.hpp"
@@ -36,6 +38,126 @@ namespace fs = std::filesystem;
 using namespace portapack;
 using namespace std::literals;

+namespace {
+fs::path get_settings_path(const std::string& app_name) {
+    return fs::path{u"/SETTINGS"} / app_name + u".ini";
+}
+}  // namespace
+
+void BoundSetting::parse(std::string_view value) {
+    switch (type_) {
+        case SettingType::I64:
+            parse_int(value, as<int64_t>());
+            break;
+        case SettingType::I32:
+            parse_int(value, as<int32_t>());
+            break;
+        case SettingType::U32:
+            parse_int(value, as<uint32_t>());
+            break;
+        case SettingType::U8:
+            parse_int(value, as<uint8_t>());
+            break;
+        case SettingType::String:
+            as<std::string>() = std::string{value};
+            break;
+        case SettingType::Bool: {
+            int parsed = 0;
+            parse_int(value, parsed);
+            as<bool>() = (parsed != 0);
+            break;
+        }
+    };
+}
+
+void BoundSetting::write(File& file) const {
+    // NB: Write directly without allocations. This happens on every
+    // app exit when enabled so should be fast to keep the UX responsive.
+    StringFormatBuffer buffer;
+    size_t length = 0;
+
+    file.write(name_.data(), name_.length());
+    file.write("=", 1);
+
+    switch (type_) {
+        case SettingType::I64:
+            file.write(to_string_dec_int(as<int64_t>(), buffer, length), length);
+            break;
+        case SettingType::I32:
+            file.write(to_string_dec_int(as<int32_t>(), buffer, length), length);
+            break;
+        case SettingType::U32:
+            file.write(to_string_dec_uint(as<uint32_t>(), buffer, length), length);
+            break;
+        case SettingType::U8:
+            file.write(to_string_dec_uint(as<uint8_t>(), buffer, length), length);
+            break;
+        case SettingType::String: {
+            const auto& str = as<std::string>();
+            file.write(str.data(), str.length());
+            break;
+        }
+        case SettingType::Bool:
+            file.write(as<bool>() ? "1" : "0", 1);
+            break;
+    }
+
+    file.write("\r\n", 2);
+}
+
+SettingsStore::SettingsStore(std::string_view store_name, SettingBindings bindings)
+    : store_name_{store_name}, bindings_{bindings} {
+    load_settings(store_name_, bindings_);
+}
+
+SettingsStore::~SettingsStore() {
+    save_settings(store_name_, bindings_);
+}
+
+bool load_settings(std::string_view store_name, SettingBindings& bindings) {
+    File f;
+    auto path = get_settings_path(std::string{store_name});
+
+    auto error = f.open(path);
+    if (error)
+        return false;
+
+    auto reader = FileLineReader(f);
+    for (const auto& line : reader) {
+        auto cols = split_string(line, '=');
+
+        if (cols.size() != 2)
+            continue;
+
+        // Find a binding with the name.
+        auto it = std::find_if(
+            bindings.begin(), bindings.end(),
+            [name = cols[0]](auto& bound_setting) {
+                return name == bound_setting.name();
+            });
+
+        // If found, parse the value.
+        if (it != bindings.end())
+            it->parse(cols[1]);
+    }
+
+    return true;
+}
+
+bool save_settings(std::string_view store_name, const SettingBindings& bindings) {
+    File f;
+    auto path = get_settings_path(std::string{store_name});
+
+    auto error = f.create(path);
+    if (error)
+        return false;
+
+    for (const auto& bound_setting : bindings)
+        bound_setting.write(f);
+
+    return true;
+}
+
 namespace app_settings {

 template <typename T>
@@ -64,10 +186,6 @@ static void write_setting(File& file, std::string_view setting_name, const T& va
    file.write("\r\n", 2);
 }

-static fs::path get_settings_path(const std::string& app_name) {
-    return fs::path{u"/SETTINGS"} / app_name + u".ini";
-}
-
 namespace setting {
 constexpr std::string_view baseband_bandwidth = "baseband_bandwidth="sv;
 constexpr std::string_view sampling_rate = "sampling_rate="sv;
@@ -88,13 +206,6 @@ constexpr std::string_view squelch = "squelch="sv;
 constexpr std::string_view volume = "volume="sv;
 }  // namespace setting

-// TODO: Only load/save values that are declared used.
-// This will prevent switching apps from changing setting unnecessarily.
-// TODO: Track which values are actually read.
-// TODO: Maybe just use a dictionary which would allow for custom settings.
-// TODO: Create a control value binding which will allow controls to
-//       be declaratively bound to a setting and persistence will be magic.
-
 ResultCode load_settings(const std::string& app_name, AppSettings& settings) {
    if (!portapack::persistent_memory::load_app_settings())
        return ResultCode::SettingsDisabled;
@@ -2,6 +2,7 @@
 * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
 * Copyright (C) 2016 Furrtek
 * Copyright (C) 2022 Arjan Onwezen
+ * Copyright (C) 2023 Kyle Reed
 *
 * This file is part of PortaPack.
 *
@@ -27,12 +28,77 @@
 #include <cstddef>
 #include <cstdint>
 #include <string>
+#include <string_view>
 #include <utility>
+#include <variant>

 #include "file.hpp"
 #include "max283x.hpp"
 #include "string_format.hpp"

+/* Represents a named setting bound to a variable instance. */
+/* Using void* instead of std::variant, because variant is a pain to dispatch over. */
+class BoundSetting {
+    /* The type of bound setting. */
+    enum class SettingType : uint8_t {
+        I64,
+        I32,
+        U32,
+        U8,
+        String,
+        Bool,
+    };
+
+   public:
+    BoundSetting(std::string_view name, int64_t* target)
+        : name_{name}, target_{target}, type_{SettingType::I64} {}
+
+    BoundSetting(std::string_view name, int32_t* target)
+        : name_{name}, target_{target}, type_{SettingType::I32} {}
+
+    BoundSetting(std::string_view name, uint32_t* target)
+        : name_{name}, target_{target}, type_{SettingType::U32} {}
+
+    BoundSetting(std::string_view name, uint8_t* target)
+        : name_{name}, target_{target}, type_{SettingType::U8} {}
+
+    BoundSetting(std::string_view name, std::string* target)
+        : name_{name}, target_{target}, type_{SettingType::String} {}
+
+    BoundSetting(std::string_view name, bool* target)
+        : name_{name}, target_{target}, type_{SettingType::Bool} {}
+
+    std::string_view name() const { return name_; }
+    void parse(std::string_view value);
+    void write(File& file) const;
+
+   private:
+    template <typename T>
+    constexpr auto& as() const {
+        return *reinterpret_cast<T*>(target_);
+    }
+
+    std::string_view name_;
+    void* target_;
+    SettingType type_;
+};
+
+using SettingBindings = std::vector<BoundSetting>;
+
+/* RAII wrapper for Settings that loads/saves to the SD card. */
+class SettingsStore {
+   public:
+    SettingsStore(std::string_view store_name, SettingBindings bindings);
+    ~SettingsStore();
+
+   private:
+    std::string_view store_name_;
+    SettingBindings bindings_;
+};
+
+bool load_settings(std::string_view store_name, SettingBindings& bindings);
+bool save_settings(std::string_view store_name, const SettingBindings& bindings);
+
 namespace app_settings {

 enum class ResultCode : uint8_t {
@@ -60,24 +60,33 @@ 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();
    };

    receiver_model.enable();
-    option_bandwidth.set_selected_index(7);  // Preselected default option 500kHz.
+    option_bandwidth.set_by_value(500000);  // better by_value than by option_bandwidth.set_selected_index(4), Preselected default option 500kHz.

    record_view.on_error = [&nav](std::string message) {
        nav.display_modal("Error", message);
@@ -71,6 +71,8 @@ POCSAGAppView::POCSAGAppView(NavigationView& nav)
    if (!settings_.loaded())
        field_frequency.set_value(initial_target_frequency);

+    check_log.set_value(enable_logging);
+
    receiver_model.enable();

    // TODO: app setting instead?
@@ -88,7 +90,6 @@ POCSAGAppView::POCSAGAppView(NavigationView& nav)
        logger->append(LOG_ROOT_DIR "/POCSAG.TXT");

    audio::output::start();
-
    baseband::set_pocsag();
 }

@@ -99,8 +100,9 @@ void POCSAGAppView::focus() {
 POCSAGAppView::~POCSAGAppView() {
    audio::output::stop();

-    // Save ignored address
+    // Save settings.
    persistent_memory::set_pocsag_ignore_address(sym_ignore.value_dec_u32());
+    enable_logging = check_log.value();

    receiver_model.disable();
    baseband::shutdown();
@@ -65,7 +65,14 @@ class POCSAGAppView : public View {
    NavigationView& nav_;
    RxRadioState radio_state_{};
    app_settings::SettingsManager settings_{
-        "rx_pocsag", app_settings::Mode::RX};
+        "rx_pocsag",
+        app_settings::Mode::RX};
+
+    // Settings
+    bool enable_logging = false;
+    SettingsStore settings_store_{
+        "rx_pocsag_ui",
+        {{"enable_logging", &enable_logging}}};

    uint32_t last_address = 0xFFFFFFFF;
    pocsag::POCSAGState pocsag_state{};
@@ -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();

@@ -57,14 +57,14 @@ class DfuMenu : public View {
        {{6 * CHARACTER_WIDTH, 11 * LINE_HEIGHT}, "M4 miss:", Color::dark_cyan()},
        {{6 * CHARACTER_WIDTH, 12 * LINE_HEIGHT}, "uptime:", Color::dark_cyan()}};

-    Text text_info_line_1{{15 * CHARACTER_WIDTH, 5 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
-    Text text_info_line_2{{15 * CHARACTER_WIDTH, 6 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
-    Text text_info_line_3{{15 * CHARACTER_WIDTH, 7 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
-    Text text_info_line_4{{15 * CHARACTER_WIDTH, 8 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
-    Text text_info_line_5{{15 * CHARACTER_WIDTH, 9 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
-    Text text_info_line_6{{15 * CHARACTER_WIDTH, 10 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
-    Text text_info_line_7{{15 * CHARACTER_WIDTH, 11 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
-    Text text_info_line_8{{15 * CHARACTER_WIDTH, 12 * LINE_HEIGHT, 5 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_1{{15 * CHARACTER_WIDTH, 5 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_2{{15 * CHARACTER_WIDTH, 6 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_3{{15 * CHARACTER_WIDTH, 7 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_4{{15 * CHARACTER_WIDTH, 8 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_5{{15 * CHARACTER_WIDTH, 9 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_6{{15 * CHARACTER_WIDTH, 10 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_7{{15 * CHARACTER_WIDTH, 11 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
+    Text text_info_line_8{{15 * CHARACTER_WIDTH, 12 * LINE_HEIGHT, 6 * CHARACTER_WIDTH, 1 * LINE_HEIGHT}, ""};
 };

 class DfuMenu2 : public View {
@@ -185,7 +185,6 @@ FileManBaseView::FileManBaseView(
      extension_filter{filter} {
    add_children({&labels,
                  &text_current,
-                  &text_info,
                  &button_exit});

    button_exit.on_select = [this, &nav](Button&) {
@@ -250,8 +249,10 @@ void FileManBaseView::refresh_list() {
        auto entry_name = truncate(entry.path, 20);

        if (entry.is_directory) {
+            auto size_str = (entry.path == parent_dir_path) ? "" : to_string_dec_uint(file_count(entry.path));
+
            menu_view.add_item(
-                {entry_name,
+                {entry_name + std::string(21 - entry_name.length(), ' ') + size_str,
                 ui::Color::yellow(),
                 &bitmap_icon_dir,
                 [this](KeyEvent key) {
@@ -278,7 +279,6 @@ void FileManBaseView::refresh_list() {
            break;
    }

-    text_info.set(menu_view.item_count() >= max_items_shown ? "Too many files!" : "");
    menu_view.set_highlighted(prev_highlight);
 }

@@ -342,7 +342,6 @@ FileSaveView::FileSaveView(
        file_{ file }
 {
        add_children({
-                &labels,
                &text_path,
                &button_edit_path,
                &text_name,
@@ -546,7 +545,6 @@ FileManagerView::FileManagerView(

    add_children({
        &menu_view,
-        &labels,
        &text_date,
        &button_rename,
        &button_delete,
@@ -560,10 +558,16 @@ FileManagerView::FileManagerView(
    });

    menu_view.on_highlight = [this]() {
-        if (selected_is_valid())
-            text_date.set(to_string_FAT_timestamp(file_created_date(get_selected_full_path())));
-        else
-            text_date.set("");
+        if (menu_view.highlighted_index() >= max_items_shown - 1) {
+            text_date.set_style(&Styles::red);
+            text_date.set("Too many files!");
+        } else {
+            text_date.set_style(&Styles::grey);
+            if (selected_is_valid())
+                text_date.set((is_directory(get_selected_full_path()) ? "Created " : "Modified ") + to_string_FAT_timestamp(file_created_date(get_selected_full_path())));
+            else
+                text_date.set("");
+        }
    };

    refresh_list();
@@ -115,11 +115,6 @@ class FileManBaseView : public View {
        {0, 2 * 8, 240, 26 * 8},
        true};

-    // HACK: for item count limit.
-    Text text_info{
-        {1 * 8, 35 * 8, 15 * 8, 16},
-        ""};
-
    Button button_exit{
        {22 * 8, 34 * 8, 8 * 8, 32},
        "Exit"};
@@ -218,11 +213,8 @@ class FileManagerView : public FileManBaseView {
    // True if the selected entry is a real file item.
    bool selected_is_valid() const;

-    Labels labels{
-        {{0, 26 * 8}, "Created ", Color::light_grey()}};
-
    Text text_date{
-        {8 * 8, 26 * 8, 19 * 8, 16},
+        {0 * 8, 26 * 8, 28 * 8, 16},
        ""};

    NewButton button_rename{
@@ -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);

@@ -37,6 +37,22 @@ namespace fs = std::filesystem;

 namespace ui {

+void ReconView::check_update_ranges_from_current() {
+    if (frequency_list.size() && current_is_valid() && current_entry().type == freqman_type::Range) {
+        if (update_ranges && !manual_mode) {
+            button_manual_start.set_text(to_string_short_freq(current_entry().frequency_a));
+            frequency_range.min = current_entry().frequency_a;
+            if (current_entry().frequency_b != 0) {
+                button_manual_end.set_text(to_string_short_freq(current_entry().frequency_b));
+                frequency_range.max = current_entry().frequency_b;
+            } else {
+                button_manual_end.set_text(to_string_short_freq(current_entry().frequency_a));
+                frequency_range.max = current_entry().frequency_a;
+            }
+        }
+    }
+}
+
 bool ReconView::current_is_valid() {
    return (unsigned)current_index < frequency_list.size();
 }
@@ -193,8 +209,23 @@ bool ReconView::recon_load_config_from_sd() {
                break;
            case 6:
                parse_int(line, wait);
+                break;
+            case 7:
+                if (!update_ranges) {
+                    parse_int(line, frequency_range.min);
+                    button_manual_start.set_text(to_string_short_freq(frequency_range.min));
+                }
+                break;
+            case 8:
+                if (!update_ranges) {
+                    parse_int(line, frequency_range.max);
+                    button_manual_end.set_text(to_string_short_freq(frequency_range.max));
+                }
                complete = true;  // NB: Last entry.
                break;
+            default:
+                complete = false;
+                break;
        }

        if (complete) break;
@@ -220,6 +251,9 @@ bool ReconView::recon_save_config_to_sd() {
    settings_file.write_line(to_string_dec_int(squelch));
    settings_file.write_line(to_string_dec_uint(recon_match_mode));
    settings_file.write_line(to_string_dec_int(wait));
+    settings_file.write_line(to_string_dec_uint(frequency_range.min));
+    settings_file.write_line(to_string_dec_uint(frequency_range.max));
+
    return true;
 }

@@ -290,19 +324,7 @@ void ReconView::handle_retune() {
        }
        if (last_index != current_index) {
            last_index = current_index;
-            if (frequency_list.size() && current_is_valid() && current_entry().type == freqman_type::Range) {
-                if (update_ranges && !manual_mode) {
-                    button_manual_start.set_text(to_string_short_freq(current_entry().frequency_a));
-                    frequency_range.min = current_entry().frequency_a;
-                    if (current_entry().frequency_b != 0) {
-                        button_manual_end.set_text(to_string_short_freq(current_entry().frequency_b));
-                        frequency_range.max = current_entry().frequency_b;
-                    } else {
-                        button_manual_end.set_text(to_string_short_freq(current_entry().frequency_a));
-                        frequency_range.max = current_entry().frequency_a;
-                    }
-                }
-            }
+            check_update_ranges_from_current();
            text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
            update_description();
        }
@@ -562,9 +584,14 @@ ReconView::ReconView(NavigationView& nav)
        recon_pause();
        if (!frequency_range.min || !frequency_range.max) {
            nav_.display_modal("Error", "Both START and END freqs\nneed a value");
-        } else if (frequency_range.min > frequency_range.max) {
-            nav_.display_modal("Error", "END freq\nis lower than START");
        } else {
+            if (frequency_range.min > frequency_range.max) {
+                std::swap(frequency_range.min, frequency_range.max);
+                button_manual_start.set_text(to_string_short_freq(frequency_range.min));
+                button_manual_end.set_text(to_string_short_freq(frequency_range.max));
+            }
+
+            // no need to stop audio in SPEC
            if (field_mode.selected_index_value() != SPEC_MODULATION)
                audio::output::stop();

@@ -839,17 +866,7 @@ void ReconView::frequency_file_load(bool) {
    receiver_model.enable();
    receiver_model.set_squelch_level(0);
    text_cycle.set_text(to_string_dec_uint(current_index + 1, 3));
-    if (update_ranges && !manual_mode) {
-        button_manual_start.set_text(to_string_short_freq(current_entry().frequency_a));
-        frequency_range.min = current_entry().frequency_a;
-        if (current_entry().frequency_b != 0) {
-            button_manual_end.set_text(to_string_short_freq(current_entry().frequency_b));
-            frequency_range.max = current_entry().frequency_b;
-        } else {
-            button_manual_end.set_text(to_string_short_freq(current_entry().frequency_a));
-            frequency_range.max = current_entry().frequency_a;
-        }
-    }
+    check_update_ranges_from_current();
    update_description();
    handle_retune();
 }
@@ -861,10 +878,6 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
    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
@@ -892,7 +905,6 @@ void ReconView::on_statistics_update(const ChannelStatistics& statistics) {
            status = 0;
            freq_lock = 0;
            timer = local_recon_lock_duration;
-            big_display.set_style(&Styles::white);
        }
        if (freq_lock < recon_lock_nb_match)  // LOCKING
        {
@@ -1234,10 +1246,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 +1263,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 {
@@ -70,6 +70,7 @@ class ReconView : public View {
    app_settings::SettingsManager settings_{
        "rx_recon", app_settings::Mode::RX};

+    void check_update_ranges_from_current();
    void set_loop_config(bool v);
    void clear_freqlist_for_ui_action();
    void reset_indexes();
@@ -110,11 +110,11 @@ class ScannerView : public View {
    std::string title() const override { return "Scanner"; };

   private:
+    RxRadioState radio_state_{};
    app_settings::SettingsManager settings_{
        "rx_scanner", app_settings::Mode::RX};

    NavigationView& nav_;
-    RxRadioState radio_state_{};

    void start_scan_thread();
    void restart_scan();
@@ -360,6 +360,8 @@ TextEditorView::TextEditorView(NavigationView& nav)
            &text_size,
        });

+    viewer.set_font_zoom(enable_zoom);
+
    viewer.on_select = [this]() {
        // Treat as if menu button was pressed.
        if (button_menu.on_select)
@@ -382,7 +384,7 @@ TextEditorView::TextEditorView(NavigationView& nav)
    };

    menu.on_zoom() = [this]() {
-        viewer.toggle_font_zoom();
+        enable_zoom = viewer.toggle_font_zoom();
        refresh_ui();
        hide_menu(true);
    };
@@ -32,6 +32,7 @@
 #include "ui_styles.hpp"
 #include "ui_widget.hpp"

+#include "app_settings.hpp"
 #include "file_wrapper.hpp"
 #include "optional.hpp"

@@ -80,7 +81,10 @@ class TextViewer : public Widget {

    const Style& style() { return *font_style; }
    void set_font_zoom(bool zoom);
-    void toggle_font_zoom() { set_font_zoom(!font_zoom); };
+    bool toggle_font_zoom() {
+        set_font_zoom(!font_zoom);
+        return font_zoom;
+    };

   private:
    bool font_zoom{};
@@ -220,6 +224,12 @@ class TextEditorView : public View {
    void on_show() override;

   private:
+    // Settings
+    bool enable_zoom = false;
+    SettingsStore settings_store_{
+        "notepad",
+        {{"enable_zoom", &enable_zoom}}};
+
    static constexpr size_t max_edit_length = 1024;
    std::string edit_line_buffer_{};

@@ -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__*/
@@ -579,6 +579,17 @@ bool is_empty_directory(const path& file_path) {
    return !((result == FR_OK) && (filinfo.fname[0] != (TCHAR)'\0'));
 }

+int file_count(const path& directory) {
+    int count{0};
+
+    for (auto& entry : std::filesystem::directory_iterator(directory, (const TCHAR*)u"*")) {
+        (void)entry;  // avoid unused warning
+        ++count;
+    }
+
+    return count;
+}
+
 space_info space(const path& p) {
    DWORD free_clusters{0};
    FATFS* fs;
@@ -250,6 +250,8 @@ bool file_exists(const path& file_path);
 bool is_directory(const path& file_path);
 bool is_empty_directory(const path& file_path);

+int file_count(const path& dir_path);
+
 space_info space(const path& p);

 } /* namespace filesystem */
@@ -74,18 +74,21 @@ options_t freqman_bandwidths[4] = {
    },
    {
        // SPEC -- TODO: these should be indexes.
-        {"8k5", 8500},
-        {"11k", 11000},
+        {"12k5", 12500},
        {"16k", 16000},
        {"25k", 25000},
+        {"32k", 32000},
        {"50k", 50000},
+        {"75k", 75000},
        {"100k", 100000},
+        {"150k", 150000},
        {"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},
@@ -267,18 +270,18 @@ std::string to_freqman_string(const freqman_entry& entry) {

    switch (entry.type) {
        case freqman_type::Single:
-            append_field("f", to_string_dec_uint64(entry.frequency_a));
+            append_field("f", to_string_dec_uint(entry.frequency_a));
            break;
        case freqman_type::Range:
-            append_field("a", to_string_dec_uint64(entry.frequency_a));
-            append_field("b", to_string_dec_uint64(entry.frequency_b));
+            append_field("a", to_string_dec_uint(entry.frequency_a));
+            append_field("b", to_string_dec_uint(entry.frequency_b));

            if (is_valid(entry.step))
                append_field("s", freqman_entry_get_step_string_short(entry.step));
            break;
        case freqman_type::HamRadio:
-            append_field("r", to_string_dec_uint64(entry.frequency_a));
-            append_field("t", to_string_dec_uint64(entry.frequency_b));
+            append_field("r", to_string_dec_uint(entry.frequency_a));
+            append_field("t", to_string_dec_uint(entry.frequency_b));

            if (is_valid(entry.tone))
                append_field("c", tonekey::tone_key_value_string(entry.tone));
@@ -1,5 +1,6 @@
 /*
 * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
+ * Copyright (C) 2023 Mark Thompson
 *
 * This file is part of PortaPack.
 *
@@ -24,9 +25,8 @@
 #include "utility.hpp"

 uint8_t Debounce::state() {
-    bool v = !pulse_upon_release_ && (state_ || simulated_pulse_);
-    if (simulated_pulse_)
-        simulated_pulse_ = false;
+    bool v = state_to_report_;
+    simulated_pulse_ = false;
    return v;
 }

@@ -52,84 +52,100 @@ bool Debounce::long_press_occurred() {
 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;
        }
-    } 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;
+
+        // "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_) {
-                // force state() function (called by EventDispatcher) to return simulated press for one cycle
-                simulated_pulse_ = true;
                pulse_upon_release_ = false;
-            } else {
-                state_ = 0;
+                simulated_pulse_ = true;
+                state_to_report_ = 1;
+                return true;
            }

-            // Reset long_press_occurred_ flag after button is released
-            long_press_occurred_ = false;
+            state_to_report_ = 0;
            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 repeat_support and long_press support are mutually exclusive)
-                if (held_time_ >= LONG_PRESS_DELAY) {
-                    long_press_occurred_ = true;
-                    simulated_pulse_ = true;
-                    pulse_upon_release_ = false;
-                    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;
+        // Reset reported state after application/event has cleared simulated_pulse_
+        if (state_to_report_ == 1 && !simulated_pulse_) {
+            state_to_report_ = 0;
+            return true;
        }
+    } else {
+        //
+        // Button is in transition between states;
+        // Reset counters until button inputs are stable.
+        //
+        held_time_ = 0;
+        repeat_ctr_ = 0;
    }
+
    return false;
 }
@@ -43,15 +43,25 @@ class Debounce {
    bool long_press_occurred();

   private:
-    uint8_t history_{0};
-    uint8_t state_{0};
-    bool repeat_enabled_{false};
-    uint16_t repeat_ctr_{0};
-    uint16_t held_time_{0};
-    bool pulse_upon_release_{false};
-    bool simulated_pulse_{false};
-    bool long_press_enabled_{false};
-    bool long_press_occurred_{false};
+    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__*/
@@ -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;
                }
@@ -59,30 +59,37 @@ static char* to_string_dec_uint_pad_internal(
    return q;
 }

-template <typename Int>
-char* to_string_dec_uint_internal(Int n, StringFormatBuffer& buffer, size_t& length) {
+static char* to_string_dec_uint_internal(uint64_t n, StringFormatBuffer& buffer, size_t& length) {
    auto end = &buffer.back();
    auto start = to_string_dec_uint_internal(end, n);
    length = end - start;
    return start;
 }

-char* to_string_dec_uint(uint32_t n, StringFormatBuffer& buffer, size_t& length) {
+char* to_string_dec_uint(uint64_t n, StringFormatBuffer& buffer, size_t& length) {
    return to_string_dec_uint_internal(n, buffer, length);
 }

-char* to_string_dec_uint64(uint64_t n, StringFormatBuffer& buffer, size_t& length) {
-    return to_string_dec_uint_internal(n, buffer, length);
+char* to_string_dec_int(int64_t n, StringFormatBuffer& buffer, size_t& length) {
+    bool negative = n < 0;
+    auto start = to_string_dec_uint(negative ? -n : n, buffer, length);
+
+    if (negative) {
+        *(--start) = '-';
+        ++length;
+    }
+
+    return start;
 }

-std::string to_string_dec_uint(uint32_t n) {
+std::string to_string_dec_int(int64_t n) {
    StringFormatBuffer b{};
    size_t len{};
-    char* str = to_string_dec_uint(n, b, len);
+    char* str = to_string_dec_int(n, b, len);
    return std::string(str, len);
 }

-std::string to_string_dec_uint64(uint64_t n) {
+std::string to_string_dec_uint(uint64_t n) {
    StringFormatBuffer b{};
    size_t len{};
    char* str = to_string_dec_uint(n, b, len);
@@ -194,14 +201,14 @@ std::string to_string_rounded_freq(const uint64_t f, int8_t precision) {
    };

    if (precision < 1) {
-        final_str = to_string_dec_uint64(f / 1000000);
+        final_str = to_string_dec_uint(f / 1000000);
    } else {
        if (precision > 6)
            precision = 6;

        uint32_t divisor = pow10[6 - precision];

-        final_str = to_string_dec_uint64(f / 1000000) + "." + to_string_dec_int(((f + (divisor / 2)) / divisor) % pow10[precision], precision, '0');
+        final_str = to_string_dec_uint(f / 1000000) + "." + to_string_dec_int(((f + (divisor / 2)) / divisor) % pow10[precision], precision, '0');
    }
    return final_str;
 }
@@ -43,17 +43,17 @@ const char unit_prefix[7]{'n', 'u', 'm', 0, 'k', 'M', 'G'};

 using StringFormatBuffer = std::array<char, 24>;

-/* uint conversion without memory allocations. */
-char* to_string_dec_uint(uint32_t n, StringFormatBuffer& buffer, size_t& length);
-char* to_string_dec_uint64(uint64_t n, StringFormatBuffer& buffer, size_t& length);
+/* Integer conversion without memory allocations. */
+char* to_string_dec_int(int64_t n, StringFormatBuffer& buffer, size_t& length);
+char* to_string_dec_uint(uint64_t n, StringFormatBuffer& buffer, size_t& length);

-std::string to_string_dec_uint(uint32_t n);
-std::string to_string_dec_uint64(uint64_t n);
+std::string to_string_dec_int(int64_t n);
+std::string to_string_dec_uint(uint64_t n);

 // TODO: Allow l=0 to not fill/justify? Already using this way in ui_spectrum.hpp...
 std::string to_string_bin(const uint32_t n, const uint8_t l = 0);
 std::string to_string_dec_uint(const uint32_t n, const int32_t l, const char fill = ' ');
-std::string to_string_dec_int(const int32_t n, const int32_t l = 0, const char fill = 0);
+std::string to_string_dec_int(const int32_t n, const int32_t l, const char fill = 0);
 std::string to_string_decimal(float decimal, int8_t precision);

 std::string to_string_hex(const uint64_t n, const int32_t l = 0);
@@ -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},
        ""};
 };

@@ -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 ... 3'500'000:  // BW Captured range (0 <= 250kHz max)  fs = 8x250 kHz =2000., 16x150 khz =2400, 32x100 khz =3200, (32x75k = 2400), (future 64x40 khz =2400)
+            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) {  // yellow REC button means not ok for REC, BW >1Mhz  (BW from 12k5 till 1Mhz OK for REC and Replay)
        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 /8, /16, /32 for decimation.
+    if (rate < OversampleRate::x8)  // clipping while /4 is not implemented yet  (it will be used >1Mhz onwards when available)
+        rate = OversampleRate::x8;
+    else if (rate > OversampleRate::x64)  // clipping while /128 is not implemented yet , (but it is not necessary for 12k5)
+        rate = OversampleRate::x64;
+
+    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,8 +27,12 @@
 #include "utility.hpp"

 CaptureProcessor::CaptureProcessor() {
-    decim_0.configure(taps_200k_decim_0.taps, 33554432);
-    decim_1.configure(taps_200k_decim_1.taps, 131072);
+    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_2.configure(taps_200k_decim_1.taps, 131072);
+    decim_1_8.configure(taps_16k0_decim_1.taps, 131072);  // tentative decim1 /8  and taps, pending to be optimized.

    channel_spectrum.set_decimation_factor(1);
    baseband_thread.start();
@@ -36,8 +40,17 @@ 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 filter , /8 180k sharp )
+    const auto decim_1_out = decim_1_execute(decim_0_out, dst_buffer);  // selectable 3 possible decim_1, (/8.  /2 200k or bypassed /1  )
+
+    /* this code was valid when we had only 2 decim1 cases.
+    const auto decim_1_out = baseband_fs < 4800'000
+                                  ? decim_1_2.execute(decim_0_out, dst_buffer)  // < 600khz double decim. stage , means 500khz and lower bit rates.
+                                 // ? decim_1_8.execute(decim_0_out, dst_buffer)  // < 600khz double decim. stage , means 500khz and lower bit rates.
+                                  : decim_0_out;                              // >= 600khz single decim. stage , means 600khz and upper bit rates.
+
+     } */
+
    const auto& decimator_out = decim_1_out;
    const auto& channel = decimator_out;

@@ -65,8 +78,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,14 +91,54 @@ 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;
+    // Current fw , we are using only  2 decim_0 modes,  /4 , /8
+    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;
+
+    size_t decim_1_factor;
+    switch (oversample_rate) {  // we are using 3 decim_1 modes,  /1 , /2 ,  /8
+        case OversampleRate::x8:
+            if (baseband_fs < 4800'000) {
+                decim_1_factor = decim_1_2.decimation_factor;  // /8 = /4x2
+            } else {
+                decim_1_factor = 2 * 1;  // 600khz and onwards, single decim /8 = /8x1 (we applied additional *2 correction to speed up waterfall, no effect to scale spectrum)
+            }
+            break;
+
+        case OversampleRate::x16:
+            decim_1_factor = 2 * decim_1_2.decimation_factor;  // /16 = /8x2 (we applied additional *2 correction to increase waterfall spped >=600k and smooth & avoid abnormal motion >1M5 )
+            break;
+
+        case OversampleRate::x32:
+            decim_1_factor = 2 * decim_1_8.decimation_factor;  // /32 = /4x8 (we applied additional *2 correction to speed up waterfall, no effect to scale spectrum)
+            break;
+
+        case OversampleRate::x64:
+            decim_1_factor = 8 * decim_1_8.decimation_factor;  // /64 = /8x8 (we applied additional *8 correction to speed up waterfall, no effect to scale spectrum)
+            break;
+
+        default:
+            decim_1_factor = 2;  // just default initial value to remove compile warning.
+            break;
+    }
+
+    /*
+    auto decim_1_factor = oversample_rate == OversampleRate::x32    // that was ok,  when we had only 2 oversampling x8 , x16
+                              ? decim_1_8.decimation_factor
+                              : decim_1_2.decimation_factor;
+
+    */
+    size_t decim_1_output_fs = decim_1_input_fs / decim_1_factor;

    channel_filter_low_f = taps_200k_decim_1.low_frequency_normalized * decim_1_input_fs;
    channel_filter_high_f = taps_200k_decim_1.high_frequency_normalized * decim_1_input_fs;
@@ -103,6 +156,54 @@ 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);  // decim_0 , /8 with double decim stage
+
+        case OversampleRate::x32:
+            return decim_0_4.execute(src, dst);  // decim_0 , /4 with double decim stage
+
+        case OversampleRate::x64:
+            return decim_0_8.execute(src, dst);  // decim_0 , /8 with double decim stage
+
+        default:
+            chDbgPanic("Unhandled OversampleRate");
+            return {};
+    }
+}
+
+buffer_c16_t CaptureProcessor::decim_1_execute(const buffer_c16_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_1_2.execute(src, dst);
+            } else {
+                return src;
+            }
+
+        case OversampleRate::x16:
+            return decim_1_2.execute(src, dst);  // total decim /16 = /8x2, applied to 100khz and 150khz
+
+        case OversampleRate::x32:
+            return decim_1_8.execute(src, dst);  // total decim /32 = /4x8, appled to  75k , 50k, 32k
+
+        case OversampleRate::x64:
+            return decim_1_8.execute(src, dst);  // total decim /64 = /8x8, appled to 16k and 12k5
+
+        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,16 @@ class CaptureProcessor : public BasebandProcessor {
        dst.data(),
        dst.size()};

-    dsp::decimate::FIRC8xR16x24FS4Decim4 decim_0{};
-    dsp::decimate::FIRC16xR16x16Decim2 decim_1{};
+    /* 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_2{};
+    dsp::decimate::FIRC16xR16x32Decim8 decim_1_8{};
+
    int32_t channel_filter_low_f = 0;
    int32_t channel_filter_high_f = 0;
    int32_t channel_filter_transition = 0;
@@ -61,14 +69,21 @@ 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);
+
+    /* Dispatch to the correct decim_1 based on oversample rate. */
+    buffer_c16_t decim_1_execute(const buffer_c16_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;
@@ -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,43 @@ 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,
+
+    /* Oversample rate of 64 times the sample rate. */
+    x64 = 64,
+
+    /* Oversample rate of 128 times the sample rate. */
+    x128 = 128,
+};
+
+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,73 @@
+/*
+ * 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.
+ *
+ * There are several different concepts or terms related to Capture and Replay,
+ * (1) oversampling (x8, x16 ,...) / decimation (/8, /16...)
+ * In Capture App , when ADC can not handle directly a requiered low sample rates ,
+ * we need to apply oversampling (x8. x16 ex) , getting more real samples than needed) by "x_number" ,
+ * and later to write it to SD card with the proper needed real sample rate , we apply Decimation  , "/ number" .
+ *
+ * (2) up-sampling or re-escale or interpolation. (x8, x16, ...)
+ * In Replay-list App, when we got too low bit rate data for Hackrf ,
+ * we need to upsampling or interpolate or resampling to increase those low bit rates
+ * to a proper sample rate higher than the min. to be able to be transmitted by Hackrf.
+ */
+
+/* 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 < 30'000) return OversampleRate::x64;   // 25k, 16k, 12k5.
+    if (sample_rate < 80'000) return OversampleRate::x32;   // 75k, 50k, 32k.
+    if (sample_rate < 250'000) return OversampleRate::x16;  // 100k and 150k.
+
+    return OversampleRate::x8;  // 250k .. 1Mhz, that decim x8 , is already applied.(OVerSampling and decim OK)
+}
+
+/* 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__*/
@@ -365,9 +365,13 @@ void Text::set(std::string_view value) {
 void Text::paint(Painter& painter) {
    const auto rect = screen_rect();
    auto s = has_focus() ? style().invert() : style();
+    auto max_len = (unsigned)rect.width() / s.font.char_width();

    painter.fill_rectangle(rect, s.background);

+    if (text.length() > max_len)
+        text.resize(max_len);
+
    painter.draw_string(
        rect.location(),
        s,
@@ -1188,7 +1192,7 @@ void NewButton::paint(Painter& painter) {
        painter.draw_bitmap(
            bmp_pos,
            *bitmap_,
-            color_,  // Color::green(), //fg,
+            color_,
            bg);
    }

@@ -1667,8 +1671,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 +1679,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 +1699,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);
 }

@@ -99,4 +99,10 @@ TEST_CASE("It should convert 8-bit.") {
    CHECK_EQ(val, 123);
 }

+TEST_CASE("It should convert negative.") {
+    int8_t val = 0;
+    REQUIRE(parse_int("-64", val));
+    CHECK_EQ(val, -64);
+}
+
 TEST_SUITE_END();
@@ -24,12 +24,27 @@

 /* TODO: Tests for all string_format functions. */

-TEST_CASE("to_string_dec_uint64 returns correct value.") {
-    CHECK_EQ(to_string_dec_uint64(0), "0");
-    CHECK_EQ(to_string_dec_uint64(1), "1");
-    CHECK_EQ(to_string_dec_uint64(1'000'000), "1000000");
-    CHECK_EQ(to_string_dec_uint64(1'234'567'890), "1234567890");
-    CHECK_EQ(to_string_dec_uint64(1'234'567'891), "1234567891");
+TEST_CASE("to_string_dec_int returns correct value.") {
+    CHECK_EQ(to_string_dec_int(0), "0");
+    CHECK_EQ(to_string_dec_int(1), "1");
+    CHECK_EQ(to_string_dec_int(-1), "-1");
+    CHECK_EQ(to_string_dec_int(1'000'000), "1000000");
+    CHECK_EQ(to_string_dec_int(-1'000'000), "-1000000");
+    CHECK_EQ(to_string_dec_int(1'234'567'890), "1234567890");
+    CHECK_EQ(to_string_dec_int(-1'234'567'890), "-1234567890");
+    CHECK_EQ(to_string_dec_int(1'234'567'891), "1234567891");
+    CHECK_EQ(to_string_dec_int(-1'234'567'891), "-1234567891");
+    CHECK_EQ(to_string_dec_int(9'876'543'210), "9876543210");
+    CHECK_EQ(to_string_dec_int(-9'876'543'210), "-9876543210");
+}
+
+TEST_CASE("to_string_dec_uint returns correct value.") {
+    CHECK_EQ(to_string_dec_uint(0), "0");
+    CHECK_EQ(to_string_dec_uint(1), "1");
+    CHECK_EQ(to_string_dec_uint(1'000'000), "1000000");
+    CHECK_EQ(to_string_dec_uint(1'234'567'890), "1234567890");
+    CHECK_EQ(to_string_dec_uint(1'234'567'891), "1234567891");
+    CHECK_EQ(to_string_dec_uint(9'876'543'210), "9876543210");
 }

 TEST_CASE("to_string_freq returns correct value.") {
Author	SHA1	Message	Date
gullradriel	cc963c3562	Recon: Only update manual field if current entry is a range (#1387 )	2023-08-18 22:05:28 +02:00
Kyle Reed	63f99742fc	First pass at custom app-settings support (#1381 ) * First draft of custom app settings support. * WIP new settings * Working per-app custom settings * Revert design to use "bound settings"	2023-08-18 12:35:41 -07:00
Brumi-2021	a4636d7872	Finalise all low bit rate Capture App with x64 (#1386 ) * Finalise all low bit rate Capture App with x64 * Adding back also 25k BW option	2023-08-18 14:49:22 +02:00
gullradriel	bd2ee03e44	Restoring part of old timer, fixed sd loading (#1385 )	2023-08-17 17:28:12 +02:00
Mark Thompson	deeb81c183	Correct text field width (#1383 )	2023-08-17 00:45:24 +02:00
Brumi-2021	12dbf957b3	Extend REC low bit rate bandwith options in Capture App till 75khz (#1380 ) * working_x32_Capture_till_75Khz * format issues * apply better accurate comments * auto format issues	2023-08-16 23:26:59 +02:00
Mark Thompson	e1cc0b1ad0	Show file count in each directory, and moved "Too many files" message (#1376 ) * Added file_count() function * Show file count in each directory; moved "Too many files!" warning	2023-08-16 10:00:46 +02:00
gullradriel	f079d57fc6	Recon: fixed behavior of auto update m-ranges (#1374 ) and coloring * Fixed behavior of auto update m-ranges, added min and max to sd load and save if option not used * changing xor swap by std::swap * Fixed consecutive green color	2023-08-15 18:29:16 +02:00
Brumi-2021	09b9ed642f	avoid yellow icon in Audio App (minor issue) (#1372 ) * avoid yellow icon in Audio App * clear readability * just more clear parentesis	2023-08-13 16:52:54 -05:00
Mark Thompson	e74a9f3b41	Limit text string length to fit Text widget rectangle (#1370 ) * Limit string length to fit Text rectangle * Update ui_widget.cpp	2023-08-13 20:34:46 +02:00
Mark Thompson	ff7a9d10cb	Load App Settings after initializing RadioState (#1371 )	2023-08-13 20:33:31 +02:00
Brumi-2021	5cfd7f1dc2	Small error correction to PR 1367 (#1368 )	2023-08-12 10:57:16 -05:00
Brumi-2021	853ca2ef53	Solve_quality_problem_low_bit_rate_100k_150k_REC_Capture_App (#1367 ) * Solve_low_bit_rate_150k_Capture_App * Applying review comments. * format issues * Adding back requested previous low bit rates	2023-08-12 09:20:15 -05:00
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