From 41ae9b3b1b6a75d12c39f1186e6d6e644f834c6f Mon Sep 17 00:00:00 2001
From: Clyne Sullivan <clyne@bitgloo.com>
Date: Thu, 28 Oct 2021 20:09:39 -0400
Subject: added cmake support

---
 source/file.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'source/file.cpp')

diff --git a/source/file.cpp b/source/file.cpp
index f6222fa..96dac0a 100644
--- a/source/file.cpp
+++ b/source/file.cpp
@@ -122,7 +122,10 @@ void fileRenderMenu()
 
 void fileRenderDialog()
 {
-    if (ImGuiFileDialog::Instance()->Display("ChooseFileOpenSave")) {
+    if (ImGuiFileDialog::Instance()->Display("ChooseFileOpenSave",
+                                             ImGuiWindowFlags_NoCollapse,
+                                             ImVec2(460, 540)))
+    {
         if (ImGuiFileDialog::Instance()->IsOk()) {
             std::string filePathName = ImGuiFileDialog::Instance()->GetFilePathName();
 
-- 
cgit v1.2.3


From 12440b673f55eb4bfac5f553923de7ce9508a2a7 Mon Sep 17 00:00:00 2001
From: Clyne Sullivan <clyne@bitgloo.com>
Date: Sat, 30 Oct 2021 10:08:11 -0400
Subject: new file on startup; styling; bug fixes

---
 .gitignore        |  1 +
 CMakeLists.txt    |  4 +++-
 source/device.cpp |  2 +-
 source/file.cpp   | 18 +++++++++---------
 source/gui.cpp    |  6 +++++-
 source/main.cpp   |  2 ++
 6 files changed, 21 insertions(+), 12 deletions(-)

(limited to 'source/file.cpp')

diff --git a/.gitignore b/.gitignore
index debda6d..d7ed0eb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+build/
 imgui.ini
 stmdspgui
 stmdspgui.exe
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d042f12..54f7086 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,13 +5,15 @@ project(stmdspgui VERSION 0.5)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 
-add_compile_options(-O0 -ggdb -g3 -Wall -Wextra -pedantic)
+add_compile_options(-O0 -ggdb -g3)
 
 file(GLOB SRC_IMGUI_BACKENDS "${CMAKE_SOURCE_DIR}/source/imgui/backends/*.cpp")
 file(GLOB SRC_IMGUI "${CMAKE_SOURCE_DIR}/source/imgui/*.cpp")
 file(GLOB SRC_STMDSP "${CMAKE_SOURCE_DIR}/source/stmdsp/*.cpp")
 file(GLOB SRC_STMDSPGUI "${CMAKE_SOURCE_DIR}/source/*.cpp")
 
+set_property(SOURCE ${SRC_STMDSPGUI} PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wpedantic")
+
 add_executable(stmdspgui
     source/serial/src/serial.cc
     source/serial/src/impl/unix.cc
diff --git a/source/device.cpp b/source/device.cpp
index 333fd81..6f052d7 100644
--- a/source/device.cpp
+++ b/source/device.cpp
@@ -519,7 +519,7 @@ void deviceRenderToolbar()
     ImGui::SameLine();
     ImGui::SetNextItemWidth(100);
     if (ImGui::BeginCombo("", sampleRatePreview)) {
-        for (int i = 0; i < sampleRateList.size(); ++i) {
+        for (unsigned int i = 0; i < sampleRateList.size(); ++i) {
             if (ImGui::Selectable(sampleRateList[i])) {
                 sampleRatePreview = sampleRateList[i];
                 if (m_device != nullptr && !m_device->is_running()) {
diff --git a/source/file.cpp b/source/file.cpp
index 96dac0a..0f0015c 100644
--- a/source/file.cpp
+++ b/source/file.cpp
@@ -56,6 +56,12 @@ static void openCurrentFile()
     }
 }
 
+void openNewFile()
+{
+    fileCurrentPath.clear();
+    editor.SetText(stmdsp::file_content);
+}
+
 void fileScanTemplates()
 {
     auto path = std::filesystem::current_path() / "templates";
@@ -68,8 +74,7 @@ void fileRenderMenu()
     if (ImGui::BeginMenu("File")) {
         if (ImGui::MenuItem("New")) {
             // TODO modified?
-            fileCurrentPath.clear();
-            editor.SetText(stmdsp::file_content);
+            openNewFile();
             log("Ready.");
         }
 
@@ -129,18 +134,13 @@ void fileRenderDialog()
         if (ImGuiFileDialog::Instance()->IsOk()) {
             std::string filePathName = ImGuiFileDialog::Instance()->GetFilePathName();
 
-            switch (fileAction) {
-            case FileAction::None:
-                break;
-            case FileAction::Open:
+	    if (fileAction == FileAction::Open) {
                 fileCurrentPath = filePathName;
                 openCurrentFile();
                 log("Ready.");
-                break;
-            case FileAction::SaveAs:
+	    } else if (fileAction == FileAction::SaveAs) {
                 fileCurrentPath = filePathName;
                 saveCurrentFile();
-                break;
             }
         }
         
diff --git a/source/gui.cpp b/source/gui.cpp
index 47291c6..2ecf8ee 100644
--- a/source/gui.cpp
+++ b/source/gui.cpp
@@ -57,6 +57,11 @@ bool guiInitialize()
     ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
     ImGui_ImplOpenGL2_Init();
 
+    ImGuiStyle& style = ImGui::GetStyle();
+    style.WindowRounding = 5;
+    style.FrameRounding = 3;
+    style.ScrollbarRounding = 1;
+
     return true;
 }
 
@@ -71,7 +76,6 @@ void guiRender(void (*func)())
 
 void guiHandleEvents(bool& done)
 {
-    SDL_Event event;
     for (SDL_Event event; SDL_PollEvent(&event);) {
         ImGui_ImplSDL2_ProcessEvent(&event);
         if (event.type == SDL_QUIT)
diff --git a/source/main.cpp b/source/main.cpp
index bea1a21..e112118 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -33,6 +33,7 @@ extern void guiRender(void (*func)());
 extern void fileRenderMenu();
 extern void fileRenderDialog();
 extern void fileScanTemplates();
+extern void openNewFile();
 
 extern void codeEditorInit();
 extern void codeRenderMenu();
@@ -62,6 +63,7 @@ int main(int, char **)
 
     fileScanTemplates();
     codeEditorInit();
+    openNewFile();
 
     while (!done) {
         auto endTime = std::chrono::steady_clock::now() +
-- 
cgit v1.2.3


From f6318e328402a5e839d24e7d52f5bb13062bccdc Mon Sep 17 00:00:00 2001
From: Clyne Sullivan <clyne@bitgloo.com>
Date: Sat, 20 Nov 2021 16:55:26 -0500
Subject: code cleanup; fix audio streaming

---
 source/code.cpp          | 133 +++++++++++++--------------
 source/device.cpp        | 230 ++++++++++++++++++++++++-----------------------
 source/file.cpp          |  26 ++++--
 source/main.cpp          |  37 ++++----
 source/stmdsp/stmdsp.cpp | 218 ++++++++++++++++++++------------------------
 source/stmdsp/stmdsp.hpp |  96 ++++++++++++++------
 source/wav.hpp           |  30 +++----
 7 files changed, 399 insertions(+), 371 deletions(-)

(limited to 'source/file.cpp')

diff --git a/source/code.cpp b/source/code.cpp
index e290440..163d6e5 100644
--- a/source/code.cpp
+++ b/source/code.cpp
@@ -33,6 +33,8 @@ std::string tempFileName; // device.cpp
 static std::string editorCompiled;
 
 static std::string newTempFileName();
+static bool codeExecuteCommand(const std::string& command, const std::string& file);
+static void stringReplaceAll(std::string& str, const std::string& what, const std::string& with);
 static void compileEditorCode();
 static void disassembleCode();
 
@@ -64,6 +66,39 @@ void codeRenderWidgets()
     editor.Render("code", {WINDOW_WIDTH - 15, 450}, true);
 }
 
+std::string newTempFileName()
+{
+    const auto path = std::filesystem::temp_directory_path() / "stmdspgui_build";
+    return path.string();
+}
+
+bool codeExecuteCommand(const std::string& command, const std::string& file)
+{
+    if (system(command.c_str()) == 0) {
+        if (std::ifstream output (file); output.good()) {
+            std::ostringstream sstr;
+            sstr << output.rdbuf();
+            log(sstr.str().c_str());
+        } else {
+            log("Could not read command output!");
+        }
+
+        std::filesystem::remove(file);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void stringReplaceAll(std::string& str, const std::string& what, const std::string& with)
+{
+    std::size_t i;
+    while ((i = str.find(what)) != std::string::npos) {
+        str.replace(i, what.size(), with);
+        i += what.size();
+    }
+};
+
 void compileEditorCode()
 {
     log("Compiling...");
@@ -74,35 +109,28 @@ void compileEditorCode()
         std::filesystem::remove(tempFileName + ".orig.o");
     }
 
-    stmdsp::platform platform;
-    if (m_device) {
-        platform = m_device->get_platform();
-    } else {
-        // Assume a default.
-        platform = stmdsp::platform::L4;
-    }
+    const auto platform = m_device ? m_device->get_platform()
+                                   : stmdsp::platform::L4;
 
-    if (tempFileName.size() == 0)
+    if (tempFileName.empty())
         tempFileName = newTempFileName();
 
+
     {
         std::ofstream file (tempFileName, std::ios::trunc | std::ios::binary);
 
-        auto file_text = platform == stmdsp::platform::L4 ? stmdsp::file_header_l4
-                                                          : stmdsp::file_header_h7;
-        auto samples_text = std::to_string(m_device ? m_device->get_buffer_size()
-                                                    : stmdsp::SAMPLES_MAX);
-        for (std::size_t i = 0; (i = file_text.find("$0", i)) != std::string::npos;) {
-            file_text.replace(i, 2, samples_text);
-            i += 2;
-        }
+        auto file_text =
+            platform == stmdsp::platform::L4 ? stmdsp::file_header_l4
+                                             : stmdsp::file_header_h7;
+        const auto buffer_size = m_device ? m_device->get_buffer_size()
+                                          : stmdsp::SAMPLES_MAX;
+
+        stringReplaceAll(file_text, "$0", std::to_string(buffer_size));
 
-        file << file_text;
-        file << "\n";
-        file << editor.GetText();
+        file << file_text << '\n' << editor.GetText();
     }
 
-    constexpr const char *script_ext =
+    const auto scriptFile = tempFileName +
 #ifndef STMDSP_WIN32
         ".sh";
 #else
@@ -110,44 +138,33 @@ void compileEditorCode()
 #endif
 
     {
-        std::ofstream makefile (tempFileName + script_ext, std::ios::binary);
-        auto make_text = platform == stmdsp::platform::L4 ? stmdsp::makefile_text_l4
-                                                          : stmdsp::makefile_text_h7;
-        auto cwd = std::filesystem::current_path().string();
-        for (std::size_t i = 0; (i = make_text.find("$0", i)) != std::string::npos;) {
-            make_text.replace(i, 2, tempFileName);
-            i += 2;
-        }
-        for (std::size_t i = 0; (i = make_text.find("$1", i)) != std::string::npos;) {
-            make_text.replace(i, 2, cwd);
-            i += 2;
-        }
+        std::ofstream makefile (scriptFile, std::ios::binary);
+        auto make_text =
+            platform == stmdsp::platform::L4 ? stmdsp::makefile_text_l4
+                                             : stmdsp::makefile_text_h7;
+
+        stringReplaceAll(make_text, "$0", tempFileName);
+        stringReplaceAll(make_text, "$1",
+                         std::filesystem::current_path().string());
 
         makefile << make_text;
     }
 
-    auto makeOutput = tempFileName + script_ext + ".log";
-    auto makeCommand = tempFileName + script_ext + " > " + makeOutput + " 2>&1";
-
 #ifndef STMDSP_WIN32
-    system((std::string("chmod +x ") + tempFileName + script_ext).c_str());
+    system((std::string("chmod +x ") + scriptFile).c_str());
 #endif
-    int result = system(makeCommand.c_str());
-    std::ifstream result_file (makeOutput);
-    std::ostringstream sstr;
-    sstr << result_file.rdbuf();
-    log(sstr.str().c_str());
-
-    std::filesystem::remove(tempFileName);
-    std::filesystem::remove(tempFileName + script_ext);
-    std::filesystem::remove(makeOutput);
 
-    if (result == 0) {
+    const auto makeOutput = scriptFile + ".log";
+    const auto makeCommand = scriptFile + " > " + makeOutput + " 2>&1";
+    if (codeExecuteCommand(makeCommand, makeOutput)) {
         editorCompiled = editor.GetText();
         log("Compilation succeeded.");
     } else {
         log("Compilation failed.");
     }
+
+    std::filesystem::remove(tempFileName);
+    std::filesystem::remove(scriptFile);
 }
 
 void disassembleCode()
@@ -158,31 +175,15 @@ void disassembleCode()
         compileEditorCode();
     }
 
-    auto output = tempFileName + ".asm.log";
-    auto command = std::string("arm-none-eabi-objdump -d --no-show-raw-insn ") +
+    const auto output = tempFileName + ".asm.log";
+    const auto command =
+        std::string("arm-none-eabi-objdump -d --no-show-raw-insn ") +
         tempFileName + ".orig.o > " + output + " 2>&1";
-    
-    if (system(command.c_str()) == 0) {
-        {
-            std::ifstream result_file (output);
-            std::ostringstream sstr;
-            sstr << result_file.rdbuf();
-            log(sstr.str().c_str());
-        }
-
-        ImGui::OpenPopup("compile");
-        std::filesystem::remove(output);
 
+    if (codeExecuteCommand(command, output)) {
         log("Ready.");
     } else {
         log("Failed to load disassembly.");
     }
 }
 
-std::string newTempFileName()
-{
-    auto tempPath = std::filesystem::temp_directory_path();
-    tempPath /= "stmdspgui_build";
-    return tempPath.string();
-}
-
diff --git a/source/device.cpp b/source/device.cpp
index 399bf7d..39bc746 100644
--- a/source/device.cpp
+++ b/source/device.cpp
@@ -9,11 +9,6 @@
  * If not, see <https://www.gnu.org/licenses/>.
  */
 
-/**
- * TODO list:
- * - Improve signal generator audio streaming.
- */
-
 #include "stmdsp.hpp"
 
 #include "imgui.h"
@@ -80,11 +75,41 @@ static unsigned int drawSamplesBufferSize = 1;
 
 static void measureCodeTask(std::shared_ptr<stmdsp::device> device)
 {
-    if (!device)
-        return;
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-    auto cycles = device->continuous_start_get_measurement();
-    log(std::string("Execution time: ") + std::to_string(cycles) + " cycles.");
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    if (device) {
+        const auto cycles = device->continuous_start_get_measurement();
+        log(std::string("Execution time: ") + std::to_string(cycles) + " cycles.");
+    }
+}
+
+static std::vector<stmdsp::dacsample_t> tryReceiveChunk(
+    std::shared_ptr<stmdsp::device> device,
+    auto readFunc)
+{
+    int tries = -1;
+    do {
+        const auto chunk = readFunc(device.get());
+        if (!chunk.empty())
+            return chunk;
+        else
+            std::this_thread::sleep_for(std::chrono::microseconds(20));
+    } while (++tries < 100 && device->is_running());
+
+    return {};
+}
+
+static std::chrono::duration<double> getBufferPeriod(
+    std::shared_ptr<stmdsp::device> device,
+    const double factor = 0.975)
+{
+    if (device) {
+        const double bufferSize = device->get_buffer_size();
+        const double sampleRate = sampleRateInts[device->get_sample_rate()];
+        return std::chrono::duration<double>(bufferSize / sampleRate * factor);
+    } else {
+        return {};
+    }
 }
 
 static void drawSamplesTask(std::shared_ptr<stmdsp::device> device)
@@ -93,71 +118,45 @@ static void drawSamplesTask(std::shared_ptr<stmdsp::device> device)
         return;
 
     const bool doLogger = logResults && logSamplesFile.good();
-
-    const double bufferSize = m_device->get_buffer_size();
-    const double sampleRate = sampleRateInts[m_device->get_sample_rate()];
-    unsigned long bufferTime = bufferSize / sampleRate * 0.975 * 1e6;
+    const auto bufferTime = getBufferPeriod(device);
 
     std::unique_lock<std::timed_mutex> lockDraw (mutexDrawSamples, std::defer_lock);
     std::unique_lock<std::timed_mutex> lockDevice (mutexDeviceLoad, std::defer_lock);
 
-    while (m_device && m_device->is_running()) {
-        auto next = std::chrono::high_resolution_clock::now() +
-                    std::chrono::microseconds(bufferTime);
+    auto addToQueue = [&lockDraw](auto& queue, const auto& chunk) {
+        lockDraw.lock();
+        std::copy(chunk.cbegin(), chunk.cend(), std::back_inserter(queue));
+        lockDraw.unlock();
+    };
 
-        std::vector<stmdsp::dacsample_t> chunk;
+    while (device && device->is_running()) {
+        const auto next = std::chrono::high_resolution_clock::now() + bufferTime;
 
         if (lockDevice.try_lock_until(next)) {
-            chunk = m_device->continuous_read();
-            int tries = -1;
-            while (chunk.empty() && m_device->is_running()) {
-                if (++tries == 100)
-                    break;
-                std::this_thread::sleep_for(std::chrono::microseconds(20));
-                chunk = m_device->continuous_read();
-            }
+            const auto chunk = tryReceiveChunk(device,
+                std::mem_fn(&stmdsp::device::continuous_read));
             lockDevice.unlock();
+
+            addToQueue(drawSamplesQueue, chunk);
+            if (doLogger) {
+                for (const auto& s : chunk)
+                    logSamplesFile << s << '\n';
+            }
         } else {
-            // Cooldown.
+            // Device must be busy, cooldown.
             std::this_thread::sleep_for(std::chrono::milliseconds(500));
         }
 
         if (drawSamplesInput && popupRequestDraw) {
-            std::vector<stmdsp::dacsample_t> chunk2;
-
             if (lockDevice.try_lock_for(std::chrono::milliseconds(1))) {
-                chunk2 = m_device->continuous_read_input();
-                int tries = -1;
-                while (chunk2.empty() && m_device->is_running()) {
-                    if (++tries == 100)
-                        break;
-                    std::this_thread::sleep_for(std::chrono::microseconds(20));
-                    chunk2 = m_device->continuous_read_input();
-                }
+                const auto chunk2 = tryReceiveChunk(device,
+                    std::mem_fn(&stmdsp::device::continuous_read_input));
                 lockDevice.unlock();
-            }
 
-            lockDraw.lock();
-            auto i = chunk2.cbegin();
-            for (const auto& s : chunk) {
-                drawSamplesQueue.push_back(s);
-                drawSamplesInputQueue.push_back(*i++);
-            }
-            lockDraw.unlock();
-        } else if (!doLogger) {
-            lockDraw.lock();
-            for (const auto& s : chunk)
-                drawSamplesQueue.push_back(s);
-            lockDraw.unlock();
-        } else {
-            lockDraw.lock();
-            for (const auto& s : chunk) {
-                drawSamplesQueue.push_back(s);
-                logSamplesFile << s << '\n';
+                addToQueue(drawSamplesInputQueue, chunk2);
             }
-            lockDraw.unlock();
         }
-        
+
         std::this_thread::sleep_until(next);
     }
 }
@@ -167,36 +166,36 @@ static void feedSigGenTask(std::shared_ptr<stmdsp::device> device)
     if (!device)
         return;
 
-    const auto bufferSize = m_device->get_buffer_size();
-    const double sampleRate = sampleRateInts[m_device->get_sample_rate()];
-    const unsigned long delay = bufferSize / sampleRate * 0.975 * 1e6;
+    const auto delay = getBufferPeriod(device);
+    const auto uploadDelay = getBufferPeriod(device, 0.001);
 
-    std::vector<stmdsp::adcsample_t> wavBuf (bufferSize, 2048);
+    std::vector<stmdsp::dacsample_t> wavBuf (device->get_buffer_size() * 2, 2048);
 
     std::unique_lock<std::timed_mutex> lockDevice (mutexDeviceLoad, std::defer_lock);
 
     lockDevice.lock();
-    // One (or both) of these freezes the device...
-    m_device->siggen_upload(wavBuf.data(), wavBuf.size());
-    //m_device->siggen_start();
+    device->siggen_upload(wavBuf.data(), wavBuf.size());
+    wavBuf.resize(wavBuf.size() / 2);
+    device->siggen_start();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
     lockDevice.unlock();
 
-    std::this_thread::sleep_for(std::chrono::microseconds(delay));
+    std::vector<int16_t> wavIntBuf (wavBuf.size());
 
-    return;
     while (genRunning) {
-        auto next = std::chrono::high_resolution_clock::now() +
-                    std::chrono::microseconds(delay);
+        const auto next = std::chrono::high_resolution_clock::now() + delay;
 
-        auto src = reinterpret_cast<uint16_t *>(wavOutput.next(bufferSize));
-        for (auto& w : wavBuf)
-            w = *src++ / 16 + 2048;
+        wavOutput.next(wavIntBuf.data(), wavIntBuf.size());
+        auto src = wavIntBuf.cbegin();
+        std::generate(wavBuf.begin(), wavBuf.end(),
+            [&src] { return static_cast<stmdsp::dacsample_t>(*src++ / 16 + 2048); });
 
-        if (lockDevice.try_lock_until(next)) {
-            m_device->siggen_upload(wavBuf.data(), wavBuf.size());
-            lockDevice.unlock();
-            std::this_thread::sleep_until(next);
-        }
+        lockDevice.lock();
+        while (!device->siggen_upload(wavBuf.data(), wavBuf.size()))
+            std::this_thread::sleep_for(uploadDelay);
+        lockDevice.unlock();
+
+        std::this_thread::sleep_until(next);
     }
 }
 
@@ -208,16 +207,20 @@ static void statusTask(std::shared_ptr<stmdsp::device> device)
     while (device->connected()) {
         std::unique_lock<std::timed_mutex> lockDevice (mutexDeviceLoad, std::defer_lock);
         lockDevice.lock();
-        auto [status, error] = device->get_status();
+        const auto [status, error] = device->get_status();
         lockDevice.unlock();
 
         if (error != stmdsp::Error::None) {
-            if (error == stmdsp::Error::NotIdle) {
+            switch (error) {
+            case stmdsp::Error::NotIdle:
                 log("Error: Device already running...");
-            } else if (error == stmdsp::Error::ConversionAborted) {
+                break;
+            case stmdsp::Error::ConversionAborted:
                 log("Error: Algorithm unloaded, a fault occurred!");
-            } else {
+                break;
+            default:
                 log("Error: Device had an issue...");
+                break;
             }
         }
 
@@ -383,13 +386,13 @@ void deviceRenderDraw()
             drawSamplesBufferSize = std::round(sr * tf);
         }
         ImGui::SameLine();
-        ImGui::Text("Y-minmax: %u", yMinMax);
+        ImGui::Text("Y: +/-%1.2fV", 3.3f * (static_cast<float>(yMinMax) / 4095.f));
         ImGui::SameLine();
-        if (ImGui::Button("--", {30, 0})) {
+        if (ImGui::Button(" - ", {30, 0})) {
             yMinMax = std::max(63u, yMinMax >> 1);
         }
         ImGui::SameLine();
-        if (ImGui::Button("++", {30, 0})) {
+        if (ImGui::Button(" + ", {30, 0})) {
             yMinMax = std::min(4095u, (yMinMax << 1) | 1);
         }
 
@@ -508,7 +511,7 @@ void deviceRenderMenu()
             popupRequestBuffer = true;
         }
         ImGui::Separator();
-        if (ImGui::MenuItem("Load signal generator", nullptr, false, isConnected && !isRunning)) {
+        if (ImGui::MenuItem("Load signal generator", nullptr, false, isConnected && !m_device->is_siggening())) {
             popupRequestSiggen = true;
         }
         static const char *startSiggenLabel = "Start signal generator";
@@ -542,22 +545,26 @@ void deviceRenderToolbar()
         deviceAlgorithmUpload();
     ImGui::SameLine();
     ImGui::SetNextItemWidth(100);
+
+    const bool enable = m_device && !m_device->is_running() && !m_device->is_siggening();
+    if (!enable)
+        ImGui::PushDisabled();
     if (ImGui::BeginCombo("", sampleRatePreview)) {
         for (unsigned int i = 0; i < sampleRateList.size(); ++i) {
             if (ImGui::Selectable(sampleRateList[i])) {
                 sampleRatePreview = sampleRateList[i];
-                if (m_device && !m_device->is_running()) {
-                    do {
-                        m_device->set_sample_rate(i);
-                        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-                    } while (m_device->get_sample_rate() != i);
+                do {
+                    m_device->set_sample_rate(i);
+                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                } while (m_device->get_sample_rate() != i);
 
-                    drawSamplesBufferSize = std::round(sampleRateInts[i] * drawSamplesTimeframe);
-                }
+                drawSamplesBufferSize = std::round(sampleRateInts[i] * drawSamplesTimeframe);
             }
         }
         ImGui::EndCombo();
     }
+    if (!enable)
+        ImGui::PopDisabled();
 }
 
 void deviceConnect()
@@ -566,7 +573,7 @@ void deviceConnect()
 
     if (!m_device) {
         stmdsp::scanner scanner;
-        if (auto devices = scanner.scan(); devices.size() > 0) {
+        if (auto devices = scanner.scan(); !devices.empty()) {
             try {
                 m_device.reset(new stmdsp::device(devices.front()));
             } catch (...) {
@@ -608,8 +615,7 @@ void deviceStart()
 
     if (m_device->is_running()) {
         {
-            std::scoped_lock lock (mutexDrawSamples);
-            std::scoped_lock lock2 (mutexDeviceLoad);
+            std::scoped_lock lock (mutexDrawSamples, mutexDeviceLoad);
             std::this_thread::sleep_for(std::chrono::microseconds(150));
             m_device->continuous_stop();
         }
@@ -637,10 +643,9 @@ void deviceAlgorithmUpload()
     if (!m_device) {
         log("No device connected.");
         return;
-    }
-
-    if (m_device->is_running())
+    } else if (m_device->is_running()) {
         return;
+    }
 
     if (std::ifstream algo (tempFileName + ".o"); algo.good()) {
         std::ostringstream sstr;
@@ -658,41 +663,38 @@ void deviceAlgorithmUnload()
 {
     if (!m_device) {
         log("No device connected.");
-        return;
-    }
-
-    if (!m_device->is_running()) {
+    } else if (!m_device->is_running()) {
         m_device->unload_filter();
         log("Algorithm unloaded.");
     }
 }
 
-void deviceGenLoadList(std::string_view listStr)
+void deviceGenLoadList(const std::string_view list)
 {
     std::vector<stmdsp::dacsample_t> samples;
 
-    while (listStr.size() > 0 && samples.size() <= stmdsp::SAMPLES_MAX * 2) {
-        auto numberEnd = listStr.find_first_not_of("0123456789");
-
+    auto it = list.cbegin();
+    while (it != list.cend() && samples.size() < stmdsp::SAMPLES_MAX * 2) {
+        const auto end = list.find_first_not_of("0123456789",
+            std::distance(list.cbegin(), it));
+        const auto itend = end != std::string_view::npos ? list.cbegin() + end
+                                                         : list.cend();
         unsigned long n;
-        auto end = numberEnd != std::string_view::npos ? listStr.begin() + numberEnd : listStr.end();
-        auto [ptr, ec] = std::from_chars(listStr.begin(), end, n);
+        const auto [ptr, ec] = std::from_chars(it, itend, n);
         if (ec != std::errc())
             break;
 
         samples.push_back(n & 4095);
-        if (end == listStr.end())
-            break;
-        listStr = listStr.substr(numberEnd + 1);
+        it = itend;
     }
 
     if (samples.size() <= stmdsp::SAMPLES_MAX * 2) {
         // DAC buffer must be of even size
-        if ((samples.size() & 1) == 1)
+        if (samples.size() % 2 != 0)
             samples.push_back(samples.back());
 
         if (m_device)
-            m_device->siggen_upload(&samples[0], samples.size());
+            m_device->siggen_upload(samples.data(), samples.size());
         log("Generator ready.");
     } else {
         log("Error: Too many samples for signal generator.");
@@ -703,9 +705,9 @@ void deviceGenLoadFormula(std::string_view formula)
 {
     auto samples = deviceGenLoadFormulaEval(formula);
 
-    if (samples.size() > 0) {
+    if (!samples.empty()) {
         if (m_device)
-            m_device->siggen_upload(&samples[0], samples.size());
+            m_device->siggen_upload(samples.data(), samples.size());
 
         log("Generator ready.");
     } else {
diff --git a/source/file.cpp b/source/file.cpp
index 0f0015c..dfd9148 100644
--- a/source/file.cpp
+++ b/source/file.cpp
@@ -17,6 +17,7 @@
 
 #include "stmdsp_code.hpp"
 
+#include <algorithm>
 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
@@ -34,6 +35,7 @@ enum class FileAction {
     Save,
     SaveAs
 };
+
 static FileAction fileAction = FileAction::None;
 static std::string fileCurrentPath;
 static std::vector<std::filesystem::path> fileTemplateList;
@@ -56,17 +58,31 @@ static void openCurrentFile()
     }
 }
 
-void openNewFile()
+static void openNewFile()
 {
     fileCurrentPath.clear();
     editor.SetText(stmdsp::file_content);
 }
 
-void fileScanTemplates()
+static std::vector<std::filesystem::path> fileScanTemplates()
+{
+    const auto path = std::filesystem::current_path() / "templates";
+    const std::filesystem::recursive_directory_iterator rdi (path);
+
+    std::vector<std::filesystem::path> list;
+    std::transform(
+        std::filesystem::begin(rdi),
+        std::filesystem::end(rdi),
+        std::back_inserter(list),
+        [](const auto& file) { return file.path(); });
+    std::sort(list.begin(), list.end());
+    return list;
+}
+
+void fileInit()
 {
-    auto path = std::filesystem::current_path() / "templates";
-    for (const auto& file : std::filesystem::recursive_directory_iterator{path})
-        fileTemplateList.push_back(file.path());
+    fileTemplateList = fileScanTemplates();
+    openNewFile();
 }
 
 void fileRenderMenu()
diff --git a/source/main.cpp b/source/main.cpp
index b98ec2b..20c8ea1 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -32,8 +32,7 @@ extern void guiRender(void (*func)());
 
 extern void fileRenderMenu();
 extern void fileRenderDialog();
-extern void fileScanTemplates();
-extern void openNewFile();
+extern void fileInit();
 
 extern void codeEditorInit();
 extern void codeRenderMenu();
@@ -60,9 +59,8 @@ int main(int, char **)
     if (!guiInitialize())
         return -1;
 
-    fileScanTemplates();
     codeEditorInit();
-    openNewFile();
+    fileInit();
 
     while (!done) {
         auto endTime = std::chrono::steady_clock::now() +
@@ -90,21 +88,22 @@ int main(int, char **)
                          ImGuiWindowFlags_NoBringToFrontOnFocus);
 
         // Render main controls (order is important).
-        ImGui::PushFont(fontSans);
-        codeRenderToolbar();
-        deviceRenderToolbar();
-        fileRenderDialog();
-        deviceRenderWidgets();
-        ImGui::PopFont();
-
-        ImGui::PushFont(fontMono);
-        codeRenderWidgets();
-        ImGui::SetNextWindowPos({0, WINDOW_HEIGHT - 200});
-        ImGui::SetNextWindowSize({WINDOW_WIDTH, 200});
-        logView.Draw("log", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoBringToFrontOnFocus);
-        ImGui::PopFont();
-
-        // Finish main view rendering.
+        {
+            ImGui::PushFont(fontSans);
+            codeRenderToolbar();
+            deviceRenderToolbar();
+            fileRenderDialog();
+            deviceRenderWidgets();
+            ImGui::PopFont();
+
+            ImGui::PushFont(fontMono);
+            codeRenderWidgets();
+            ImGui::SetNextWindowPos({0, WINDOW_HEIGHT - 200});
+            ImGui::SetNextWindowSize({WINDOW_WIDTH, 200});
+            logView.Draw("log", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoBringToFrontOnFocus);
+            ImGui::PopFont();
+        }
+
         ImGui::End();
 
         deviceRenderDraw();
diff --git a/source/stmdsp/stmdsp.cpp b/source/stmdsp/stmdsp.cpp
index 650dbc4..2bbb92b 100644
--- a/source/stmdsp/stmdsp.cpp
+++ b/source/stmdsp/stmdsp.cpp
@@ -13,18 +13,23 @@
 
 #include <serial/serial.h>
 
+#include <algorithm>
+
 extern void log(const std::string& str);
 
 namespace stmdsp
 {
-    std::list<std::string>& scanner::scan()
+    const std::forward_list<std::string>& scanner::scan()
     {
         auto devices = serial::list_ports();
-        for (auto& device : devices) {
-            if (device.hardware_id.find(STMDSP_USB_ID) != std::string::npos)
-                m_available_devices.emplace_front(device.port);
-        }
-
+        auto foundDevicesEnd = std::remove_if(
+            devices.begin(), devices.end(),
+            [](const auto& dev) {
+                return dev.hardware_id.find(STMDSP_USB_ID) == std::string::npos;
+            });
+        std::transform(devices.begin(), foundDevicesEnd,
+            std::front_inserter(m_available_devices),
+            [](const auto& dev) { return dev.port; });
         return m_available_devices;
     }
 
@@ -33,6 +38,7 @@ namespace stmdsp
         // This could throw!
         m_serial.reset(new serial::Serial(file, 8'000'000, serial::Timeout::simpleTimeout(50)));
 
+        // Test the ID command.
         m_serial->flush();
         m_serial->write("i");
         auto id = m_serial->read(7);
@@ -66,98 +72,80 @@ namespace stmdsp
             m_serial.release();
     }
 
-    void device::continuous_set_buffer_size(unsigned int size) {
-        if (connected()) {
-            m_buffer_size = size;
-
-            uint8_t request[3] = {
-                'B',
-                static_cast<uint8_t>(size),
-                static_cast<uint8_t>(size >> 8)
-            };
+    bool device::try_command(std::basic_string<uint8_t> cmd) {
+        bool success = false;
 
+        if (connected()) {
             try {
-                m_serial->write(request, 3);
+                std::scoped_lock lock (m_lock);
+                m_serial->write(cmd.data(), cmd.size());
+                success = true;
             } catch (...) {
                 m_serial.release();
                 log("Lost connection!");
             }
         }
+
+        return success;
     }
 
-    void device::set_sample_rate(unsigned int id) {
-        if (connected()) {
-            uint8_t request[2] = {
-                'r',
-                static_cast<uint8_t>(id)
-            };
+    bool device::try_read(std::basic_string<uint8_t> cmd, uint8_t *dest, unsigned int dest_size) {
+        bool success = false;
 
+        if (connected() && dest && dest_size > 0) {
             try {
-                m_serial->write(request, 2);
+                std::scoped_lock lock (m_lock);
+                m_serial->write(cmd.data(), cmd.size());
+                m_serial->read(dest, dest_size);
+                success = true;
             } catch (...) {
                 m_serial.release();
                 log("Lost connection!");
             }
         }
+
+        return success;
     }
 
-    unsigned int device::get_sample_rate() {
-        if (connected() && !is_running()) {
-            uint8_t request[2] = {
-                'r', 0xFF
-            };
+    void device::continuous_set_buffer_size(unsigned int size) {
+        if (try_command({
+                'B',
+                static_cast<uint8_t>(size),
+                static_cast<uint8_t>(size >> 8)}))
+        {
+            m_buffer_size = size;
+        }
+    }
 
-            unsigned char result = 0xFF;
-            try {
-                m_serial->write(request, 2);
-                m_serial->read(&result, 1);
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
+    void device::set_sample_rate(unsigned int id) {
+        try_command({
+            'r',
+            static_cast<uint8_t>(id)
+        });
+    }
 
-            m_sample_rate = result;
+    unsigned int device::get_sample_rate() {
+        if (!is_running()) {
+            uint8_t result = 0xFF;
+            if (try_read({'r', 0xFF}, &result, 1))
+                m_sample_rate = result;
         }
-
         return m_sample_rate;
     }
 
     void device::continuous_start() {
-        if (connected()) {
-            try {
-                m_serial->write("R");
-                m_is_running = true;
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
-        }
+        if (try_command({'R'}))
+            m_is_running = true;
     }
 
     void device::continuous_start_measure() {
-        if (connected()) {
-            try {
-                m_serial->write("M");
-                m_is_running = true;
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
-        }
+        if (try_command({'M'}))
+            m_is_running = true;
     }
 
     uint32_t device::continuous_start_get_measurement() {
         uint32_t count = 0;
-        if (connected()) {
-            try {
-                m_serial->write("m");
-                m_serial->read(reinterpret_cast<uint8_t *>(&count), sizeof(uint32_t));
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
-        }
-
+        try_read({'m'}, reinterpret_cast<uint8_t *>(&count), sizeof(uint32_t));
         return count / 2;
     }
 
@@ -226,18 +214,11 @@ namespace stmdsp
     }
 
     void device::continuous_stop() {
-        if (connected()) {
-            try {
-                m_serial->write("S");
-                m_is_running = false;
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
-        }
+        if (try_command({'S'}))
+            m_is_running = false;
     }
 
-    void device::siggen_upload(dacsample_t *buffer, unsigned int size) {
+    bool device::siggen_upload(dacsample_t *buffer, unsigned int size) {
         if (connected()) {
             uint8_t request[3] = {
                 'D',
@@ -245,39 +226,41 @@ namespace stmdsp
                 static_cast<uint8_t>(size >> 8)
             };
 
-            try {
-                m_serial->write(request, 3);
-                // TODO different write size if feeding audio?
-                m_serial->write((uint8_t *)buffer, size * sizeof(dacsample_t));
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
+            if (!m_is_siggening) {
+                try {
+                    m_serial->write(request, 3);
+                    m_serial->write((uint8_t *)buffer, size * sizeof(dacsample_t));
+                } catch (...) {
+                    m_serial.release();
+                    log("Lost connection!");
+                }
+            } else {
+                try {
+                    m_serial->write(request, 3);
+                    if (m_serial->read(1)[0] == 0)
+                        return false;
+                    else
+                        m_serial->write((uint8_t *)buffer, size * sizeof(dacsample_t));
+                } catch (...) {
+                    m_serial.release();
+                    log("Lost connection!");
+                }
             }
+
+            return true;
+        } else {
+            return false;
         }
     }
 
     void device::siggen_start() {
-        if (connected()) {
-            try {
-                m_serial->write("W");
-                m_is_siggening = true;
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
-        }
+        if (try_command({'W'}))
+            m_is_siggening = true;
     }
 
     void device::siggen_stop() {
-        if (connected()) {
-            try {
-                m_serial->write("w");
-                m_is_siggening = false;
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
-        }
+        if (try_command({'w'}))
+            m_is_siggening = false;
     }
 
     void device::upload_filter(unsigned char *buffer, size_t size) {
@@ -299,33 +282,22 @@ namespace stmdsp
     }
 
     void device::unload_filter() {
-        if (connected()) {
-            try {
-                m_serial->write("e");
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
-        }
+        try_command({'e'});
     }
 
     std::pair<RunStatus, Error> device::get_status() {
         std::pair<RunStatus, Error> ret;
 
-        if (connected()) {
-            try {
-                m_serial->write("I");
-                auto result = m_serial->read(2);
-                ret = {static_cast<RunStatus>(result[0]),
-                       static_cast<Error>(result[1])};
-
-                bool running = ret.first == RunStatus::Running;
-                if (m_is_running != running)
-                    m_is_running = running;
-            } catch (...) {
-                m_serial.release();
-                log("Lost connection!");
-            }
+        unsigned char buf[2];
+        if (try_read({'I'}, buf, 2)) {
+            ret = {
+                static_cast<RunStatus>(buf[0]),
+                static_cast<Error>(buf[1])
+            };
+
+            bool running = ret.first == RunStatus::Running;
+            if (m_is_running != running)
+                m_is_running = running;
         }
 
         return ret;
diff --git a/source/stmdsp/stmdsp.hpp b/source/stmdsp/stmdsp.hpp
index 76ca94e..64f5aff 100644
--- a/source/stmdsp/stmdsp.hpp
+++ b/source/stmdsp/stmdsp.hpp
@@ -15,33 +15,83 @@
 #include <serial/serial.h>
 
 #include <cstdint>
-#include <list>
+#include <forward_list>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <tuple>
 
 namespace stmdsp
 {
+    /**
+     * The largest possible size of an ADC or DAC sample buffer, as a sample count.
+     * Maximum byte size would be `SAMPLES_MAX * sizeof(XXXsample_t)`.
+     */
     constexpr unsigned int SAMPLES_MAX = 4096;
 
+    /**
+     * ADC samples on all platforms are stored as 16-bit unsigned integers.
+     */
+    using adcsample_t = uint16_t;
+    /**
+     * DAC samples on all platforms are stored as 16-bit unsigned integers.
+     */
+    using dacsample_t = uint16_t;
+
+    /**
+     * List of all available platforms.
+     * Note that some platforms in this list may not have complete support.
+     */
+    enum class platform {
+        Unknown,
+        H7, /* Some feature support */
+        L4, /* Complete feature support */
+        G4  /* Unsupported, but planned */
+    };
+
+    /**
+     * Run status states, valued to match what the stmdsp firmware reports.
+     */
     enum class RunStatus : char {
-        Idle = '1',
-        Running,
-        Recovering
+        Idle = '1', /* Device ready for commands or execution. */
+        Running,    /* Device currently executing its algorithm. */
+        Recovering  /* Device recovering from fault caused by algorithm. */
     };
 
+    /**
+     * Error messages that are reported by the firmware.
+     */
     enum class Error : char {
         None = 0,
-        BadParam,
-        BadParamSize,
-        BadUserCodeLoad,
-        BadUserCodeSize,
-        NotIdle,
-        ConversionAborted
+        BadParam,         /* An invalid parameter was passed for a command. */
+        BadParamSize,     /* An invaild param. size was given for a command. */
+        BadUserCodeLoad,  /* Device failed to load the given algorithm. */
+        BadUserCodeSize,  /* The given algorithm is too large for the device. */
+        NotIdle,          /* An idle-only command was received while not Idle. */
+        ConversionAborted /* A conversion was aborted due to a fault. */
     };
 
+    /**
+     * Provides functionality to scan the system for stmdsp devices.
+     * A list of devices is returned, though the GUI only interacts with one
+     * device at a time.
+     */
     class scanner
     {
+    public:
+        /**
+         * Scans for connected devices, returning a list of ports with
+         * connected stmdsp devices.
+         */
+        const std::forward_list<std::string>& scan();
+
+        /**
+         * Retrieves the results of the last scan().
+         */
+        const std::forward_list<std::string>& devices() const noexcept {
+            return m_available_devices;
+        }
+
     private:
         constexpr static const char *STMDSP_USB_ID =
 #ifndef STMDSP_WIN32
@@ -50,24 +100,7 @@ namespace stmdsp
             "USB\\VID_0483&PID_5740";
 #endif
 
-    public:
-        std::list<std::string>& scan();
-        auto& devices() {
-            return m_available_devices;
-        }
-
-    private:
-        std::list<std::string> m_available_devices;
-    };
-
-    using adcsample_t = uint16_t;
-    using dacsample_t = uint16_t;
-
-    enum class platform {
-        Unknown,
-        H7, /* Behind in feature support */
-        L4, /* Complete feature support */
-        G4  /* Currently unsupported */
+        std::forward_list<std::string> m_available_devices;
     };
 
     class device
@@ -96,7 +129,7 @@ namespace stmdsp
         std::vector<adcsample_t> continuous_read();
         std::vector<adcsample_t> continuous_read_input();
 
-        void siggen_upload(dacsample_t *buffer, unsigned int size);
+        bool siggen_upload(dacsample_t *buffer, unsigned int size);
         void siggen_start();
         void siggen_stop();
 
@@ -116,6 +149,11 @@ namespace stmdsp
         unsigned int m_sample_rate = 0;
         bool m_is_siggening = false;
         bool m_is_running = false;
+
+        std::mutex m_lock;
+
+        bool try_command(std::basic_string<uint8_t> data);
+        bool try_read(std::basic_string<uint8_t> cmd, uint8_t *dest, unsigned int dest_size);
     };
 }
 
diff --git a/source/wav.hpp b/source/wav.hpp
index 9ff06e5..71842bd 100644
--- a/source/wav.hpp
+++ b/source/wav.hpp
@@ -4,6 +4,7 @@
 #include <cstdint>
 #include <cstring>
 #include <fstream>
+#include <vector>
 
 namespace wav
 {
@@ -64,31 +65,30 @@ namespace wav
                 file.read(reinterpret_cast<char *>(&d), sizeof(wav::data));
                 if (!d.valid())
                     return;
-                m_data = new char[d.size + 4096 - (d.size % 4096)];
-                m_size = d.size;
-                file.read(m_data, d.size);
+                m_data.resize(d.size / sizeof(int16_t));
+                m_next = m_data.begin();
+                file.read(reinterpret_cast<char *>(m_data.data()), d.size);
             }
         }
         clip() = default;
 
         bool valid() const {
-            return m_data != nullptr && m_size > 0;
+            return !m_data.empty();
         }
-        auto data() const {
-            return m_data;
+        const int16_t *data() const {
+            return m_data.data();
         }
-        auto next(unsigned int chunksize = 3000) {
-            if (m_pos == m_size) {
-                m_pos = 0;
+        void next(int16_t *buf, unsigned int size) {
+            for (unsigned int i = 0; i < size; ++i) {
+                if (m_next == m_data.end())
+                    m_next = m_data.begin();
+                else
+                    *buf++ = *m_next++;
             }
-            auto ret = m_data + m_pos;
-            m_pos = std::min(m_pos + chunksize, m_size);
-            return ret;
         }
     private:
-        char *m_data = nullptr;
-        uint32_t m_size = 0;
-        uint32_t m_pos = 0;
+        std::vector<int16_t> m_data;
+        decltype(m_data.begin()) m_next;
     };
 }
 
-- 
cgit v1.2.3


From fde531e7c44ea917f745a9f800178fbe83fa19b5 Mon Sep 17 00:00:00 2001
From: Clyne Sullivan <clyne@bitgloo.com>
Date: Mon, 22 Nov 2021 19:44:48 -0500
Subject: more refactor; draw samples grid and cursor; gen load fixes

---
 Makefile                    |   2 +-
 source/circular.hpp         |  32 ++++
 source/device.cpp           | 151 +++++++++----------
 source/device_formula.cpp   |  12 +-
 source/file.cpp             |   6 +-
 source/gui.cpp              |   6 +-
 source/gui_device.cpp       | 129 +++++++++++-----
 source/imgui/TextEditor.cpp | 356 +-------------------------------------------
 source/imgui/TextEditor.h   |   6 -
 source/imgui/imgui.h        |   6 +-
 source/logview.cpp          |  82 ++++++++++
 source/logview.h            |  80 +---------
 source/main.cpp             | 143 +++++++++---------
 13 files changed, 389 insertions(+), 622 deletions(-)
 create mode 100644 source/circular.hpp
 create mode 100644 source/logview.cpp

(limited to 'source/file.cpp')

diff --git a/Makefile b/Makefile
index 26e0208..81e580d 100644
--- a/Makefile
+++ b/Makefile
@@ -24,7 +24,7 @@ $(OUTPUT): $(OFILES)
 
 clean:
 	@echo "  CLEAN"
-	@rm $(OFILES) $(OUTPUT)
+	@rm -f $(OFILES) $(OUTPUT)
 
 %.o: %.cpp
 	@echo "  CXX   " $<
diff --git a/source/circular.hpp b/source/circular.hpp
new file mode 100644
index 0000000..33b8ee0
--- /dev/null
+++ b/source/circular.hpp
@@ -0,0 +1,32 @@
+#ifndef CIRCULAR_HPP
+#define CIRCULAR_HPP
+
+#include <iterator>
+
+template<template<typename> class Container, typename T>
+class CircularBuffer
+{
+public:
+    CircularBuffer(Container<T>& container) :
+        m_begin(std::begin(container)),
+        m_end(std::end(container)),
+        m_current(std::begin(container)) {}
+
+    void put(const T& value) noexcept {
+        *m_current = value;
+        if (++m_current == m_end)
+            m_current = m_begin;
+    }
+
+    std::size_t size() const noexcept {
+        return std::distance(m_begin, m_end);
+    }
+
+private:
+    Container<T>::iterator m_begin;
+    Container<T>::iterator m_end;
+    Container<T>::iterator m_current;
+};
+
+#endif // CIRCULAR_HPP
+
diff --git a/source/device.cpp b/source/device.cpp
index df3f361..abcc88a 100644
--- a/source/device.cpp
+++ b/source/device.cpp
@@ -11,10 +11,12 @@
 
 #include "stmdsp.hpp"
 
+#include "circular.hpp"
 #include "imgui.h"
 #include "wav.hpp"
 
 #include <array>
+#include <cctype>
 #include <charconv>
 #include <cmath>
 #include <deque>
@@ -30,7 +32,7 @@
 
 extern std::string tempFileName;
 extern void log(const std::string& str);
-extern std::vector<stmdsp::dacsample_t> deviceGenLoadFormulaEval(const std::string_view);
+extern std::vector<stmdsp::dacsample_t> deviceGenLoadFormulaEval(const std::string&);
 
 std::shared_ptr<stmdsp::device> m_device;
 
@@ -62,14 +64,16 @@ static std::vector<stmdsp::dacsample_t> tryReceiveChunk(
     std::shared_ptr<stmdsp::device> device,
     auto readFunc)
 {
-    int tries = -1;
-    do {
+    for (int tries = 0; tries < 100; ++tries) {
+        if (!device->is_running())
+            break;
+
         const auto chunk = readFunc(device.get());
         if (!chunk.empty())
             return chunk;
         else
             std::this_thread::sleep_for(std::chrono::microseconds(20));
-    } while (++tries < 100 && device->is_running());
+    }
 
     return {};
 }
@@ -94,15 +98,13 @@ static void drawSamplesTask(std::shared_ptr<stmdsp::device> device)
 
     const auto bufferTime = getBufferPeriod(device);
 
-    std::unique_lock<std::timed_mutex> lockDraw (mutexDrawSamples, std::defer_lock);
-    std::unique_lock<std::timed_mutex> lockDevice (mutexDeviceLoad, std::defer_lock);
-
-    auto addToQueue = [&lockDraw](auto& queue, const auto& chunk) {
-        lockDraw.lock();
+    const auto addToQueue = [](auto& queue, const auto& chunk) {
+        std::scoped_lock lock (mutexDrawSamples);
         std::copy(chunk.cbegin(), chunk.cend(), std::back_inserter(queue));
-        lockDraw.unlock();
     };
 
+    std::unique_lock<std::timed_mutex> lockDevice (mutexDeviceLoad, std::defer_lock);
+
     while (device && device->is_running()) {
         const auto next = std::chrono::high_resolution_clock::now() + bufferTime;
 
@@ -112,7 +114,7 @@ static void drawSamplesTask(std::shared_ptr<stmdsp::device> device)
             lockDevice.unlock();
 
             addToQueue(drawSamplesQueue, chunk);
-            if (logSamplesFile.good()) {
+            if (logSamplesFile.is_open()) {
                 for (const auto& s : chunk)
                     logSamplesFile << s << '\n';
             }
@@ -145,29 +147,29 @@ static void feedSigGenTask(std::shared_ptr<stmdsp::device> device)
 
     std::vector<stmdsp::dacsample_t> wavBuf (device->get_buffer_size() * 2, 2048);
 
-    std::unique_lock<std::timed_mutex> lockDevice (mutexDeviceLoad, std::defer_lock);
+    {
+        std::scoped_lock lock (mutexDeviceLoad);
+        device->siggen_upload(wavBuf.data(), wavBuf.size());
+        device->siggen_start();
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
 
-    lockDevice.lock();
-    device->siggen_upload(wavBuf.data(), wavBuf.size());
     wavBuf.resize(wavBuf.size() / 2);
-    device->siggen_start();
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-    lockDevice.unlock();
-
     std::vector<int16_t> wavIntBuf (wavBuf.size());
 
     while (device->is_siggening()) {
         const auto next = std::chrono::high_resolution_clock::now() + delay;
 
         wavOutput.next(wavIntBuf.data(), wavIntBuf.size());
-        auto src = wavIntBuf.cbegin();
-        std::generate(wavBuf.begin(), wavBuf.end(),
-            [&src] { return static_cast<stmdsp::dacsample_t>(*src++ / 16 + 2048); });
+        std::transform(wavIntBuf.cbegin(), wavIntBuf.cend(),
+            wavBuf.begin(),
+            [](auto i) { return static_cast<stmdsp::dacsample_t>(i / 16 + 2048); });
 
-        lockDevice.lock();
-        while (!device->siggen_upload(wavBuf.data(), wavBuf.size()))
-            std::this_thread::sleep_for(uploadDelay);
-        lockDevice.unlock();
+        {
+            std::scoped_lock lock (mutexDeviceLoad);
+            while (!device->siggen_upload(wavBuf.data(), wavBuf.size()))
+                std::this_thread::sleep_for(uploadDelay);
+        }
 
         std::this_thread::sleep_until(next);
     }
@@ -179,10 +181,9 @@ static void statusTask(std::shared_ptr<stmdsp::device> device)
         return;
 
     while (device->connected()) {
-        std::unique_lock<std::timed_mutex> lockDevice (mutexDeviceLoad, std::defer_lock);
-        lockDevice.lock();
+        mutexDeviceLoad.lock();
         const auto [status, error] = device->get_status();
-        lockDevice.unlock();
+        mutexDeviceLoad.unlock();
 
         if (error != stmdsp::Error::None) {
             switch (error) {
@@ -214,7 +215,7 @@ void deviceLoadAudioFile(const std::string& file)
 void deviceLoadLogFile(const std::string& file)
 {
     logSamplesFile = std::ofstream(file);
-    if (logSamplesFile.good())
+    if (logSamplesFile.is_open())
         log("Log file ready.");
     else
         log("Error: Could not open log file.");
@@ -261,7 +262,7 @@ bool deviceConnect()
 
     if (!m_device) {
         stmdsp::scanner scanner;
-        if (auto devices = scanner.scan(); !devices.empty()) {
+        if (const auto devices = scanner.scan(); !devices.empty()) {
             try {
                 m_device.reset(new stmdsp::device(devices.front()));
             } catch (...) {
@@ -307,7 +308,7 @@ void deviceStart(bool measureCodeTime, bool logResults, bool drawSamples)
             std::this_thread::sleep_for(std::chrono::microseconds(150));
             m_device->continuous_stop();
         }
-        if (logSamplesFile.good()) {
+        if (logSamplesFile.is_open()) {
             logSamplesFile.close();
             log("Log file saved and closed.");
         }
@@ -329,12 +330,9 @@ void deviceAlgorithmUpload()
 {
     if (!m_device) {
         log("No device connected.");
-        return;
     } else if (m_device->is_running()) {
-        return;
-    }
-
-    if (std::ifstream algo (tempFileName + ".o"); algo.good()) {
+        log("Cannot upload algorithm while running.");
+    } else if (std::ifstream algo (tempFileName + ".o"); algo.is_open()) {
         std::ostringstream sstr;
         sstr << algo.rdbuf();
         auto str = sstr.str();
@@ -350,7 +348,9 @@ void deviceAlgorithmUnload()
 {
     if (!m_device) {
         log("No device connected.");
-    } else if (!m_device->is_running()) {
+    } else if (m_device->is_running()) {
+        log("Cannot unload algorithm while running.");
+    } else {
         m_device->unload_filter();
         log("Algorithm unloaded.");
     }
@@ -361,85 +361,82 @@ void deviceGenLoadList(const std::string_view list)
     std::vector<stmdsp::dacsample_t> samples;
 
     auto it = list.cbegin();
-    while (it != list.cend() && samples.size() < stmdsp::SAMPLES_MAX * 2) {
-        const auto end = list.find_first_not_of("0123456789",
-            std::distance(list.cbegin(), it));
-        const auto itend = end != std::string_view::npos ? list.cbegin() + end
-                                                         : list.cend();
+    while (it != list.cend()) {
+        const auto itend = std::find_if(it, list.cend(),
+            [](char c) { return !isdigit(c); });
+
         unsigned long n;
-        const auto [ptr, ec] = std::from_chars(it, itend, n);
-        if (ec != std::errc())
+        const auto ec = std::from_chars(it, itend, n).ec;
+        if (ec != std::errc()) {
+            log("Error: Bad data in sample list.");
+            break;
+        } else if (n > 4095) {
+            log("Error: Sample data value larger than max of 4095.");
             break;
+        } else {
+            samples.push_back(n & 4095);
+            if (samples.size() >= stmdsp::SAMPLES_MAX * 2) {
+                log("Error: Too many samples for signal generator.");
+                break;
+            }
+        }
 
-        samples.push_back(n & 4095);
         it = itend;
     }
 
-    if (samples.size() <= stmdsp::SAMPLES_MAX * 2) {
+    if (it == list.cend()) {
         // DAC buffer must be of even size
         if (samples.size() % 2 != 0)
             samples.push_back(samples.back());
 
-        if (m_device)
-            m_device->siggen_upload(samples.data(), samples.size());
+        m_device->siggen_upload(samples.data(), samples.size());
         log("Generator ready.");
-    } else {
-        log("Error: Too many samples for signal generator.");
     }
 }
 
-void deviceGenLoadFormula(std::string_view formula)
+void deviceGenLoadFormula(const std::string& formula)
 {
     auto samples = deviceGenLoadFormulaEval(formula);
 
     if (!samples.empty()) {
-        if (m_device)
-            m_device->siggen_upload(samples.data(), samples.size());
-
+        m_device->siggen_upload(samples.data(), samples.size());
         log("Generator ready.");
     } else {
         log("Error: Bad formula.");
     }
 }
 
-void pullFromQueue(
+std::size_t pullFromQueue(
     std::deque<stmdsp::dacsample_t>& queue,
-    std::vector<stmdsp::dacsample_t>& buffer,
-    decltype(buffer.begin())& bufferCursor,
+    CircularBuffer<std::vector, stmdsp::dacsample_t>& circ,
     double timeframe)
 {
-    if (buffer.size() != drawSamplesBufferSize) {
-        buffer.resize(drawSamplesBufferSize);
-        bufferCursor = buffer.begin();
-    }
+    if (circ.size() != drawSamplesBufferSize)
+        return drawSamplesBufferSize;
 
     std::scoped_lock lock (mutexDrawSamples);
 
-    auto count = drawSamplesBufferSize / (60. * timeframe) * 1.025;
-    count = std::min(drawSamplesInputQueue.size(),
-        static_cast<std::size_t>(count));
-    for (auto i = count; i; --i) {
-        *bufferCursor = queue.front();
+    const auto desiredCount = drawSamplesBufferSize / (60. * timeframe) * 1.025;
+    auto count = std::min(queue.size(), static_cast<std::size_t>(desiredCount));
+    while (count--) {
+        circ.put(queue.front());
         queue.pop_front();
-
-        if (++bufferCursor == buffer.end())
-            bufferCursor = buffer.begin();
     }
+
+    return 0;
 }
 
-void pullFromDrawQueue(
-    std::vector<stmdsp::dacsample_t>& buffer,
-    decltype(buffer.begin())& bufferCursor,
+std::size_t pullFromDrawQueue(
+    CircularBuffer<std::vector, stmdsp::dacsample_t>& circ,
     double timeframe)
 {
-    pullFromQueue(drawSamplesQueue, buffer, bufferCursor, timeframe);
+    return pullFromQueue(drawSamplesQueue, circ, timeframe);
 }
 
-void pullFromInputDrawQueue(
-    std::vector<stmdsp::dacsample_t>& buffer,
-    decltype(buffer.begin())& bufferCursor,
+std::size_t pullFromInputDrawQueue(
+    CircularBuffer<std::vector, stmdsp::dacsample_t>& circ,
     double timeframe)
 {
-    pullFromQueue(drawSamplesInputQueue, buffer, bufferCursor, timeframe);
+    return pullFromQueue(drawSamplesInputQueue, circ, timeframe);
 }
 
diff --git a/source/device_formula.cpp b/source/device_formula.cpp
index 5c1ca16..c94eab7 100644
--- a/source/device_formula.cpp
+++ b/source/device_formula.cpp
@@ -5,7 +5,7 @@
 #include <string_view>
 #include <vector>
 
-std::vector<stmdsp::dacsample_t> deviceGenLoadFormulaEval(const std::string_view formulaString)
+std::vector<stmdsp::dacsample_t> deviceGenLoadFormulaEval(const std::string& formulaString)
 {
     double x = 0;
 
@@ -16,13 +16,17 @@ std::vector<stmdsp::dacsample_t> deviceGenLoadFormulaEval(const std::string_view
     symbol_table.add_variable("x", x);
     symbol_table.add_constants();
     expression.register_symbol_table(symbol_table);
-    parser.compile(std::string(formulaString), expression);
+    parser.compile(formulaString, expression);
 
     std::vector<stmdsp::dacsample_t> samples (stmdsp::SAMPLES_MAX);
 
-    std::generate(samples.begin(), samples.end(),
-                  [&] { ++x; return static_cast<stmdsp::dacsample_t>(expression.value()); });
+    auto genFun = [&x, &expression] {
+        stmdsp::dacsample_t s = expression.value();
+        ++x;
+        return s;
+    };
 
+    std::generate(samples.begin(), samples.end(), genFun);
     return samples;
 }
 
diff --git a/source/file.cpp b/source/file.cpp
index dfd9148..a5ef1d8 100644
--- a/source/file.cpp
+++ b/source/file.cpp
@@ -26,6 +26,8 @@
 #include <string>
 #include <vector>
 
+#include <SDL2/SDL.h>
+
 extern TextEditor editor;
 extern void log(const std::string& str);
 
@@ -133,8 +135,8 @@ void fileRenderMenu()
 
         ImGui::Separator();
         if (ImGui::MenuItem("Quit")) {
-            extern bool done;
-            done = true;
+            SDL_Event quitEvent (SDL_QUIT);
+            SDL_PushEvent(&quitEvent);
         }
 
         ImGui::EndMenu();
diff --git a/source/gui.cpp b/source/gui.cpp
index 9720442..515d471 100644
--- a/source/gui.cpp
+++ b/source/gui.cpp
@@ -108,8 +108,10 @@ void guiRender(void (*func)())
    SDL_GL_SwapWindow(window);
 }
 
-void guiHandleEvents(bool& done)
+bool guiHandleEvents()
 {
+    bool done = false;
+
     for (SDL_Event event; SDL_PollEvent(&event);) {
         ImGui_ImplSDL2_ProcessEvent(&event);
         if (event.type == SDL_QUIT)
@@ -117,6 +119,8 @@ void guiHandleEvents(bool& done)
         if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
             done = true;
     }
+
+    return done;
 }
 
 void guiShutdown()
diff --git a/source/gui_device.cpp b/source/gui_device.cpp
index 5399c8b..a1d0555 100644
--- a/source/gui_device.cpp
+++ b/source/gui_device.cpp
@@ -1,3 +1,4 @@
+#include "circular.hpp"
 #include "imgui.h"
 #include "imgui_internal.h"
 #include "ImGuiFileDialog.h"
@@ -5,6 +6,7 @@
 #include "stmdsp.hpp"
 
 #include <array>
+#include <cstdio>
 #include <memory>
 #include <string>
 #include <string_view>
@@ -15,7 +17,7 @@ extern std::shared_ptr<stmdsp::device> m_device;
 void deviceAlgorithmUnload();
 void deviceAlgorithmUpload();
 bool deviceConnect();
-void deviceGenLoadFormula(std::string_view list);
+void deviceGenLoadFormula(const std::string& list);
 void deviceGenLoadList(std::string_view list);
 bool deviceGenStartToggle();
 void deviceLoadAudioFile(const std::string& file);
@@ -24,13 +26,11 @@ void deviceSetSampleRate(unsigned int index);
 void deviceSetInputDrawing(bool enabled);
 void deviceStart(bool measureCodeTime, bool logResults, bool drawSamples);
 void deviceUpdateDrawBufferSize(double timeframe);
-void pullFromDrawQueue(
-    std::vector<stmdsp::dacsample_t>& buffer,
-    decltype(buffer.begin())& bufferCursor,
+std::size_t pullFromDrawQueue(
+    CircularBuffer<std::vector, stmdsp::dacsample_t>& circ,
     double timeframe);
-void pullFromInputDrawQueue(
-    std::vector<stmdsp::dacsample_t>& buffer,
-    decltype(buffer.begin())& bufferCursor,
+std::size_t pullFromInputDrawQueue(
+    CircularBuffer<std::vector, stmdsp::dacsample_t>& circ,
     double timeframe);
 
 static std::string sampleRatePreview = "?";
@@ -56,11 +56,8 @@ void deviceRenderMenu()
     };
 
     if (ImGui::BeginMenu("Run")) {
-        const bool isConnected = m_device ? true : false;
-        const bool isRunning = isConnected && m_device->is_running();
-
         static std::string connectLabel ("Connect");
-        addMenuItem(connectLabel, !isConnected || !isRunning, [&] {
+        addMenuItem(connectLabel, !m_device || !m_device->is_running(), [&] {
                 if (deviceConnect()) {
                     connectLabel = "Disconnect";
                     sampleRatePreview =
@@ -68,9 +65,15 @@ void deviceRenderMenu()
                     deviceUpdateDrawBufferSize(drawSamplesTimeframe);
                 } else {
                     connectLabel = "Connect";
+                    measureCodeTime = false;
+                    logResults = false;
+                    drawSamples = false;
                 }
             });
 
+        const bool isConnected = m_device ? true : false;
+        const bool isRunning = isConnected && m_device->is_running();
+
         ImGui::Separator();
 
         static std::string startLabel ("Start");
@@ -153,12 +156,11 @@ void deviceRenderToolbar()
 
 void deviceRenderWidgets()
 {
-    static std::string siggenInput;
+    static std::string siggenInput (32768, '\0');
     static int siggenOption = 0;
 
     if (popupRequestSiggen) {
         popupRequestSiggen = false;
-        siggenInput.clear();
         ImGui::OpenPopup("siggen");
     } else if (popupRequestBuffer) {
         popupRequestBuffer = false;
@@ -166,15 +168,19 @@ void deviceRenderWidgets()
     } else if (popupRequestLog) {
         popupRequestLog = false;
         ImGuiFileDialog::Instance()->OpenModal(
-            "ChooseFileLogGen", "Choose File", ".csv", ".");
+            "ChooseFileLog", "Choose File", ".csv", ".");
     }
 
     if (ImGui::BeginPopup("siggen")) {
-        if (ImGui::RadioButton("List", &siggenOption, 0))
-            siggenInput.clear();
+        if (ImGui::RadioButton("List", &siggenOption, 0)) {
+            siggenInput.resize(32768);
+            siggenInput[0] = '\0';
+        }
         ImGui::SameLine();
-        if (ImGui::RadioButton("Formula", &siggenOption, 1))
-            siggenInput.clear();
+        if (ImGui::RadioButton("Formula", &siggenOption, 1)) {
+            siggenInput.resize(1024);
+            siggenInput[0] = '\0';
+        }
         ImGui::SameLine();
         if (ImGui::RadioButton("Audio File", &siggenOption, 2))
             siggenInput.clear();
@@ -183,7 +189,7 @@ void deviceRenderWidgets()
             if (ImGui::Button("Choose File")) {
                 // This dialog will override the siggen popup, closing it.
                 ImGuiFileDialog::Instance()->OpenModal(
-                    "ChooseFileLogGen", "Choose File", ".wav", ".");
+                    "ChooseFileGen", "Choose File", ".wav", ".");
             }
         } else {
             ImGui::Text(siggenOption == 0 ? "Enter a list of numbers:"
@@ -201,10 +207,10 @@ void deviceRenderWidgets()
         if (ImGui::Button("Save")) {
             switch (siggenOption) {
             case 0:
-                deviceGenLoadList(siggenInput);
+                deviceGenLoadList(siggenInput.substr(0, siggenInput.find('\0')));
                 break;
             case 1:
-                deviceGenLoadFormula(siggenInput);
+                deviceGenLoadFormula(siggenInput.substr(0, siggenInput.find('\0')));
                 break;
             case 2:
                 break;
@@ -238,18 +244,27 @@ void deviceRenderWidgets()
         ImGui::EndPopup();
     }
 
-    if (ImGuiFileDialog::Instance()->Display("ChooseFileLogGen",
+    if (ImGuiFileDialog::Instance()->Display("ChooseFileLog",
                                              ImGuiWindowFlags_NoCollapse,
                                              ImVec2(460, 540)))
     {
         if (ImGuiFileDialog::Instance()->IsOk()) {
-            auto filePathName = ImGuiFileDialog::Instance()->GetFilePathName();
-            auto ext = filePathName.substr(filePathName.size() - 4);
+            const auto filePathName = ImGuiFileDialog::Instance()->GetFilePathName();
+            deviceLoadLogFile(filePathName);
+        } else {
+            logResults = false;
+        }
+
+        ImGuiFileDialog::Instance()->Close();
+    }
 
-            if (ext.compare(".wav") == 0)
-                deviceLoadAudioFile(filePathName);
-            else if (ext.compare(".csv") == 0)
-                deviceLoadLogFile(filePathName);
+    if (ImGuiFileDialog::Instance()->Display("ChooseFileGen",
+                                             ImGuiWindowFlags_NoCollapse,
+                                             ImVec2(460, 540)))
+    {
+        if (ImGuiFileDialog::Instance()->IsOk()) {
+            const auto filePathName = ImGuiFileDialog::Instance()->GetFilePathName();
+            deviceLoadAudioFile(filePathName);
         }
 
         ImGuiFileDialog::Instance()->Close();
@@ -260,9 +275,9 @@ void deviceRenderDraw()
 {
     if (drawSamples) {
         static std::vector<stmdsp::dacsample_t> buffer;
-        static decltype(buffer.begin()) bufferCursor;
         static std::vector<stmdsp::dacsample_t> bufferInput;
-        static decltype(bufferInput.begin()) bufferInputCursor;
+        static auto bufferCirc = CircularBuffer(buffer);
+        static auto bufferInputCirc = CircularBuffer(bufferInput);
 
         static bool drawSamplesInput = false;
         static unsigned int yMinMax = 4095;
@@ -295,16 +310,50 @@ void deviceRenderDraw()
             yMinMax = std::min(4095u, (yMinMax << 1) | 1);
         }
 
-        pullFromDrawQueue(buffer, bufferCursor, drawSamplesTimeframe);
-        if (drawSamplesInput)
-            pullFromInputDrawQueue(bufferInput, bufferInputCursor, drawSamplesTimeframe);
+        auto newSize = pullFromDrawQueue(bufferCirc, drawSamplesTimeframe);
+        if (newSize > 0) {
+            buffer.resize(newSize);
+            bufferCirc = CircularBuffer(buffer);
+            pullFromDrawQueue(bufferCirc, drawSamplesTimeframe);
+        }
+
+        if (drawSamplesInput) {
+            auto newSize = pullFromInputDrawQueue(bufferInputCirc, drawSamplesTimeframe);
+            if (newSize > 0) {
+                bufferInput.resize(newSize);
+                bufferInputCirc = CircularBuffer(bufferInput);
+                pullFromInputDrawQueue(bufferInputCirc, drawSamplesTimeframe);
+            }
+        }
 
         auto drawList = ImGui::GetWindowDrawList();
         ImVec2 p0 = ImGui::GetWindowPos();
         auto size = ImGui::GetWindowSize();
         p0.y += 65;
         size.y -= 70;
-        drawList->AddRectFilled(p0, {p0.x + size.x, p0.y + size.y}, IM_COL32(0, 0, 0, 255));
+        drawList->AddRectFilled(p0, {p0.x + size.x, p0.y + size.y}, IM_COL32_BLACK);
+
+        const auto lcMinor = ImGui::GetColorU32(IM_COL32(40, 40, 40, 255));
+        const auto lcMajor = ImGui::GetColorU32(IM_COL32(140, 140, 140, 255));
+
+        {
+            const float yinc = (3. / 3.3) * size.y / 12.f;
+            const float center = p0.y + size.y / 2;
+            drawList->AddLine({p0.x, center}, {p0.x + size.x, center}, ImGui::GetColorU32(IM_COL32_WHITE));
+            for (int i = 1; i < 7; ++i) {
+                drawList->AddLine({p0.x, center + i * yinc}, {p0.x + size.x, center + i * yinc}, (i % 2) ? lcMinor : lcMajor);
+                drawList->AddLine({p0.x, center - i * yinc}, {p0.x + size.x, center - i * yinc}, (i % 2) ? lcMinor : lcMajor);
+            }
+        }
+        {
+            const float xinc = size.x / 16.f;
+            const float center = p0.x + size.x / 2;
+            drawList->AddLine({center, p0.y}, {center, p0.y + size.y}, ImGui::GetColorU32(IM_COL32_WHITE));
+            for (int i = 1; i < 8; ++i) {
+                drawList->AddLine({center + i * xinc, p0.y}, {center + i * xinc, p0.y + size.y}, (i % 2) ? lcMinor : lcMajor);
+                drawList->AddLine({center - i * xinc, p0.y}, {center - i * xinc, p0.y + size.y}, (i % 2) ? lcMinor : lcMajor);
+            }
+        }
 
         const float di = static_cast<float>(buffer.size()) / size.x;
         const float dx = std::ceil(size.x / static_cast<float>(buffer.size()));
@@ -334,6 +383,18 @@ void deviceRenderDraw()
             }
         }
 
+        const auto mouse = ImGui::GetMousePos();
+        if (mouse.x > p0.x && mouse.x < p0.x + size.x &&
+            mouse.y > p0.y && mouse.y < p0.y + size.y)
+        {
+            const std::size_t si = (mouse.x - p0.x) / size.x * buffer.size();
+            const float s = buffer[si] / 4095.f * 6.6f - 3.3f;
+            char buf[12];
+            snprintf(buf, 16, "   %1.3fV", s);
+            drawList->AddLine({mouse.x, p0.y}, {mouse.x, p0.y + size.y}, IM_COL32(255, 255, 0, 255));
+            drawList->AddText(ImGui::GetMousePos(), IM_COL32(210, 210, 0, 255), buf);
+        }
+
         ImGui::End();
     }
 }
diff --git a/source/imgui/TextEditor.cpp b/source/imgui/TextEditor.cpp
index 02966f0..b45a21e 100644
--- a/source/imgui/TextEditor.cpp
+++ b/source/imgui/TextEditor.cpp
@@ -50,7 +50,7 @@ TextEditor::TextEditor()
 	, mStartTime(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count())
 {
 	SetPalette(GetDarkPalette());
-	SetLanguageDefinition(LanguageDefinition::HLSL());
+	SetLanguageDefinition(LanguageDefinition::CPlusPlus());
 	mLines.push_back(Line());
 }
 
@@ -2804,357 +2804,3 @@ const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::CPlusPlus(
 	return langDef;
 }
 
-const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::HLSL()
-{
-	static bool inited = false;
-	static LanguageDefinition langDef;
-	if (!inited)
-	{
-		static const char* const keywords[] = {
-			"AppendStructuredBuffer", "asm", "asm_fragment", "BlendState", "bool", "break", "Buffer", "ByteAddressBuffer", "case", "cbuffer", "centroid", "class", "column_major", "compile", "compile_fragment",
-			"CompileShader", "const", "continue", "ComputeShader", "ConsumeStructuredBuffer", "default", "DepthStencilState", "DepthStencilView", "discard", "do", "double", "DomainShader", "dword", "else",
-			"export", "extern", "false", "float", "for", "fxgroup", "GeometryShader", "groupshared", "half", "Hullshader", "if", "in", "inline", "inout", "InputPatch", "int", "interface", "line", "lineadj",
-			"linear", "LineStream", "matrix", "min16float", "min10float", "min16int", "min12int", "min16uint", "namespace", "nointerpolation", "noperspective", "NULL", "out", "OutputPatch", "packoffset",
-			"pass", "pixelfragment", "PixelShader", "point", "PointStream", "precise", "RasterizerState", "RenderTargetView", "return", "register", "row_major", "RWBuffer", "RWByteAddressBuffer", "RWStructuredBuffer",
-			"RWTexture1D", "RWTexture1DArray", "RWTexture2D", "RWTexture2DArray", "RWTexture3D", "sample", "sampler", "SamplerState", "SamplerComparisonState", "shared", "snorm", "stateblock", "stateblock_state",
-			"static", "string", "struct", "switch", "StructuredBuffer", "tbuffer", "technique", "technique10", "technique11", "texture", "Texture1D", "Texture1DArray", "Texture2D", "Texture2DArray", "Texture2DMS",
-			"Texture2DMSArray", "Texture3D", "TextureCube", "TextureCubeArray", "true", "typedef", "triangle", "triangleadj", "TriangleStream", "uint", "uniform", "unorm", "unsigned", "vector", "vertexfragment",
-			"VertexShader", "void", "volatile", "while",
-			"bool1","bool2","bool3","bool4","double1","double2","double3","double4", "float1", "float2", "float3", "float4", "int1", "int2", "int3", "int4", "in", "out", "inout",
-			"uint1", "uint2", "uint3", "uint4", "dword1", "dword2", "dword3", "dword4", "half1", "half2", "half3", "half4",
-			"float1x1","float2x1","float3x1","float4x1","float1x2","float2x2","float3x2","float4x2",
-			"float1x3","float2x3","float3x3","float4x3","float1x4","float2x4","float3x4","float4x4",
-			"half1x1","half2x1","half3x1","half4x1","half1x2","half2x2","half3x2","half4x2",
-			"half1x3","half2x3","half3x3","half4x3","half1x4","half2x4","half3x4","half4x4",
-		};
-		for (auto& k : keywords)
-			langDef.mKeywords.insert(k);
-
-		static const char* const identifiers[] = {
-			"abort", "abs", "acos", "all", "AllMemoryBarrier", "AllMemoryBarrierWithGroupSync", "any", "asdouble", "asfloat", "asin", "asint", "asint", "asuint",
-			"asuint", "atan", "atan2", "ceil", "CheckAccessFullyMapped", "clamp", "clip", "cos", "cosh", "countbits", "cross", "D3DCOLORtoUBYTE4", "ddx",
-			"ddx_coarse", "ddx_fine", "ddy", "ddy_coarse", "ddy_fine", "degrees", "determinant", "DeviceMemoryBarrier", "DeviceMemoryBarrierWithGroupSync",
-			"distance", "dot", "dst", "errorf", "EvaluateAttributeAtCentroid", "EvaluateAttributeAtSample", "EvaluateAttributeSnapped", "exp", "exp2",
-			"f16tof32", "f32tof16", "faceforward", "firstbithigh", "firstbitlow", "floor", "fma", "fmod", "frac", "frexp", "fwidth", "GetRenderTargetSampleCount",
-			"GetRenderTargetSamplePosition", "GroupMemoryBarrier", "GroupMemoryBarrierWithGroupSync", "InterlockedAdd", "InterlockedAnd", "InterlockedCompareExchange",
-			"InterlockedCompareStore", "InterlockedExchange", "InterlockedMax", "InterlockedMin", "InterlockedOr", "InterlockedXor", "isfinite", "isinf", "isnan",
-			"ldexp", "length", "lerp", "lit", "log", "log10", "log2", "mad", "max", "min", "modf", "msad4", "mul", "noise", "normalize", "pow", "printf",
-			"Process2DQuadTessFactorsAvg", "Process2DQuadTessFactorsMax", "Process2DQuadTessFactorsMin", "ProcessIsolineTessFactors", "ProcessQuadTessFactorsAvg",
-			"ProcessQuadTessFactorsMax", "ProcessQuadTessFactorsMin", "ProcessTriTessFactorsAvg", "ProcessTriTessFactorsMax", "ProcessTriTessFactorsMin",
-			"radians", "rcp", "reflect", "refract", "reversebits", "round", "rsqrt", "saturate", "sign", "sin", "sincos", "sinh", "smoothstep", "sqrt", "step",
-			"tan", "tanh", "tex1D", "tex1D", "tex1Dbias", "tex1Dgrad", "tex1Dlod", "tex1Dproj", "tex2D", "tex2D", "tex2Dbias", "tex2Dgrad", "tex2Dlod", "tex2Dproj",
-			"tex3D", "tex3D", "tex3Dbias", "tex3Dgrad", "tex3Dlod", "tex3Dproj", "texCUBE", "texCUBE", "texCUBEbias", "texCUBEgrad", "texCUBElod", "texCUBEproj", "transpose", "trunc"
-		};
-		for (auto& k : identifiers)
-		{
-			Identifier id;
-			id.mDeclaration = "Built-in function";
-			langDef.mIdentifiers.insert(std::make_pair(std::string(k), id));
-		}
-
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[ \\t]*#[ \\t]*[a-zA-Z_]+", PaletteIndex::Preprocessor));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\'\\\\?[^\\']\\'", PaletteIndex::CharLiteral));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation));
-
-		langDef.mCommentStart = "/*";
-		langDef.mCommentEnd = "*/";
-		langDef.mSingleLineComment = "//";
-
-		langDef.mCaseSensitive = true;
-		langDef.mAutoIndentation = true;
-
-		langDef.mName = "HLSL";
-
-		inited = true;
-	}
-	return langDef;
-}
-
-const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::GLSL()
-{
-	static bool inited = false;
-	static LanguageDefinition langDef;
-	if (!inited)
-	{
-		static const char* const keywords[] = {
-			"auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "inline", "int", "long", "register", "restrict", "return", "short",
-			"signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while", "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary",
-			"_Noreturn", "_Static_assert", "_Thread_local"
-		};
-		for (auto& k : keywords)
-			langDef.mKeywords.insert(k);
-
-		static const char* const identifiers[] = {
-			"abort", "abs", "acos", "asin", "atan", "atexit", "atof", "atoi", "atol", "ceil", "clock", "cosh", "ctime", "div", "exit", "fabs", "floor", "fmod", "getchar", "getenv", "isalnum", "isalpha", "isdigit", "isgraph",
-			"ispunct", "isspace", "isupper", "kbhit", "log10", "log2", "log", "memcmp", "modf", "pow", "putchar", "putenv", "puts", "rand", "remove", "rename", "sinh", "sqrt", "srand", "strcat", "strcmp", "strerror", "time", "tolower", "toupper"
-		};
-		for (auto& k : identifiers)
-		{
-			Identifier id;
-			id.mDeclaration = "Built-in function";
-			langDef.mIdentifiers.insert(std::make_pair(std::string(k), id));
-		}
-
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[ \\t]*#[ \\t]*[a-zA-Z_]+", PaletteIndex::Preprocessor));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\'\\\\?[^\\']\\'", PaletteIndex::CharLiteral));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation));
-
-		langDef.mCommentStart = "/*";
-		langDef.mCommentEnd = "*/";
-		langDef.mSingleLineComment = "//";
-
-		langDef.mCaseSensitive = true;
-		langDef.mAutoIndentation = true;
-
-		langDef.mName = "GLSL";
-
-		inited = true;
-	}
-	return langDef;
-}
-
-const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::C()
-{
-	static bool inited = false;
-	static LanguageDefinition langDef;
-	if (!inited)
-	{
-		static const char* const keywords[] = {
-			"auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "inline", "int", "long", "register", "restrict", "return", "short",
-			"signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while", "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary",
-			"_Noreturn", "_Static_assert", "_Thread_local"
-		};
-		for (auto& k : keywords)
-			langDef.mKeywords.insert(k);
-
-		static const char* const identifiers[] = {
-			"abort", "abs", "acos", "asin", "atan", "atexit", "atof", "atoi", "atol", "ceil", "clock", "cosh", "ctime", "div", "exit", "fabs", "floor", "fmod", "getchar", "getenv", "isalnum", "isalpha", "isdigit", "isgraph",
-			"ispunct", "isspace", "isupper", "kbhit", "log10", "log2", "log", "memcmp", "modf", "pow", "putchar", "putenv", "puts", "rand", "remove", "rename", "sinh", "sqrt", "srand", "strcat", "strcmp", "strerror", "time", "tolower", "toupper"
-		};
-		for (auto& k : identifiers)
-		{
-			Identifier id;
-			id.mDeclaration = "Built-in function";
-			langDef.mIdentifiers.insert(std::make_pair(std::string(k), id));
-		}
-
-		langDef.mTokenize = [](const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end, PaletteIndex & paletteIndex) -> bool
-		{
-			paletteIndex = PaletteIndex::Max;
-
-			while (in_begin < in_end && isascii(*in_begin) && isblank(*in_begin))
-				in_begin++;
-
-			if (in_begin == in_end)
-			{
-				out_begin = in_end;
-				out_end = in_end;
-				paletteIndex = PaletteIndex::Default;
-			}
-			else if (TokenizeCStyleString(in_begin, in_end, out_begin, out_end))
-				paletteIndex = PaletteIndex::String;
-			else if (TokenizeCStyleCharacterLiteral(in_begin, in_end, out_begin, out_end))
-				paletteIndex = PaletteIndex::CharLiteral;
-			else if (TokenizeCStyleIdentifier(in_begin, in_end, out_begin, out_end))
-				paletteIndex = PaletteIndex::Identifier;
-			else if (TokenizeCStyleNumber(in_begin, in_end, out_begin, out_end))
-				paletteIndex = PaletteIndex::Number;
-			else if (TokenizeCStylePunctuation(in_begin, in_end, out_begin, out_end))
-				paletteIndex = PaletteIndex::Punctuation;
-
-			return paletteIndex != PaletteIndex::Max;
-		};
-
-		langDef.mCommentStart = "/*";
-		langDef.mCommentEnd = "*/";
-		langDef.mSingleLineComment = "//";
-
-		langDef.mCaseSensitive = true;
-		langDef.mAutoIndentation = true;
-
-		langDef.mName = "C";
-
-		inited = true;
-	}
-	return langDef;
-}
-
-const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::SQL()
-{
-	static bool inited = false;
-	static LanguageDefinition langDef;
-	if (!inited)
-	{
-		static const char* const keywords[] = {
-			"ADD", "EXCEPT", "PERCENT", "ALL", "EXEC", "PLAN", "ALTER", "EXECUTE", "PRECISION", "AND", "EXISTS", "PRIMARY", "ANY", "EXIT", "PRINT", "AS", "FETCH", "PROC", "ASC", "FILE", "PROCEDURE",
-			"AUTHORIZATION", "FILLFACTOR", "PUBLIC", "BACKUP", "FOR", "RAISERROR", "BEGIN", "FOREIGN", "READ", "BETWEEN", "FREETEXT", "READTEXT", "BREAK", "FREETEXTTABLE", "RECONFIGURE",
-			"BROWSE", "FROM", "REFERENCES", "BULK", "FULL", "REPLICATION", "BY", "FUNCTION", "RESTORE", "CASCADE", "GOTO", "RESTRICT", "CASE", "GRANT", "RETURN", "CHECK", "GROUP", "REVOKE",
-			"CHECKPOINT", "HAVING", "RIGHT", "CLOSE", "HOLDLOCK", "ROLLBACK", "CLUSTERED", "IDENTITY", "ROWCOUNT", "COALESCE", "IDENTITY_INSERT", "ROWGUIDCOL", "COLLATE", "IDENTITYCOL", "RULE",
-			"COLUMN", "IF", "SAVE", "COMMIT", "IN", "SCHEMA", "COMPUTE", "INDEX", "SELECT", "CONSTRAINT", "INNER", "SESSION_USER", "CONTAINS", "INSERT", "SET", "CONTAINSTABLE", "INTERSECT", "SETUSER",
-			"CONTINUE", "INTO", "SHUTDOWN", "CONVERT", "IS", "SOME", "CREATE", "JOIN", "STATISTICS", "CROSS", "KEY", "SYSTEM_USER", "CURRENT", "KILL", "TABLE", "CURRENT_DATE", "LEFT", "TEXTSIZE",
-			"CURRENT_TIME", "LIKE", "THEN", "CURRENT_TIMESTAMP", "LINENO", "TO", "CURRENT_USER", "LOAD", "TOP", "CURSOR", "NATIONAL", "TRAN", "DATABASE", "NOCHECK", "TRANSACTION",
-			"DBCC", "NONCLUSTERED", "TRIGGER", "DEALLOCATE", "NOT", "TRUNCATE", "DECLARE", "NULL", "TSEQUAL", "DEFAULT", "NULLIF", "UNION", "DELETE", "OF", "UNIQUE", "DENY", "OFF", "UPDATE",
-			"DESC", "OFFSETS", "UPDATETEXT", "DISK", "ON", "USE", "DISTINCT", "OPEN", "USER", "DISTRIBUTED", "OPENDATASOURCE", "VALUES", "DOUBLE", "OPENQUERY", "VARYING","DROP", "OPENROWSET", "VIEW",
-			"DUMMY", "OPENXML", "WAITFOR", "DUMP", "OPTION", "WHEN", "ELSE", "OR", "WHERE", "END", "ORDER", "WHILE", "ERRLVL", "OUTER", "WITH", "ESCAPE", "OVER", "WRITETEXT"
-		};
-
-		for (auto& k : keywords)
-			langDef.mKeywords.insert(k);
-
-		static const char* const identifiers[] = {
-			"ABS",  "ACOS",  "ADD_MONTHS",  "ASCII",  "ASCIISTR",  "ASIN",  "ATAN",  "ATAN2",  "AVG",  "BFILENAME",  "BIN_TO_NUM",  "BITAND",  "CARDINALITY",  "CASE",  "CAST",  "CEIL",
-			"CHARTOROWID",  "CHR",  "COALESCE",  "COMPOSE",  "CONCAT",  "CONVERT",  "CORR",  "COS",  "COSH",  "COUNT",  "COVAR_POP",  "COVAR_SAMP",  "CUME_DIST",  "CURRENT_DATE",
-			"CURRENT_TIMESTAMP",  "DBTIMEZONE",  "DECODE",  "DECOMPOSE",  "DENSE_RANK",  "DUMP",  "EMPTY_BLOB",  "EMPTY_CLOB",  "EXP",  "EXTRACT",  "FIRST_VALUE",  "FLOOR",  "FROM_TZ",  "GREATEST",
-			"GROUP_ID",  "HEXTORAW",  "INITCAP",  "INSTR",  "INSTR2",  "INSTR4",  "INSTRB",  "INSTRC",  "LAG",  "LAST_DAY",  "LAST_VALUE",  "LEAD",  "LEAST",  "LENGTH",  "LENGTH2",  "LENGTH4",
-			"LENGTHB",  "LENGTHC",  "LISTAGG",  "LN",  "LNNVL",  "LOCALTIMESTAMP",  "LOG",  "LOWER",  "LPAD",  "LTRIM",  "MAX",  "MEDIAN",  "MIN",  "MOD",  "MONTHS_BETWEEN",  "NANVL",  "NCHR",
-			"NEW_TIME",  "NEXT_DAY",  "NTH_VALUE",  "NULLIF",  "NUMTODSINTERVAL",  "NUMTOYMINTERVAL",  "NVL",  "NVL2",  "POWER",  "RANK",  "RAWTOHEX",  "REGEXP_COUNT",  "REGEXP_INSTR",
-			"REGEXP_REPLACE",  "REGEXP_SUBSTR",  "REMAINDER",  "REPLACE",  "ROUND",  "ROWNUM",  "RPAD",  "RTRIM",  "SESSIONTIMEZONE",  "SIGN",  "SIN",  "SINH",
-			"SOUNDEX",  "SQRT",  "STDDEV",  "SUBSTR",  "SUM",  "SYS_CONTEXT",  "SYSDATE",  "SYSTIMESTAMP",  "TAN",  "TANH",  "TO_CHAR",  "TO_CLOB",  "TO_DATE",  "TO_DSINTERVAL",  "TO_LOB",
-			"TO_MULTI_BYTE",  "TO_NCLOB",  "TO_NUMBER",  "TO_SINGLE_BYTE",  "TO_TIMESTAMP",  "TO_TIMESTAMP_TZ",  "TO_YMINTERVAL",  "TRANSLATE",  "TRIM",  "TRUNC", "TZ_OFFSET",  "UID",  "UPPER",
-			"USER",  "USERENV",  "VAR_POP",  "VAR_SAMP",  "VARIANCE",  "VSIZE "
-		};
-		for (auto& k : identifiers)
-		{
-			Identifier id;
-			id.mDeclaration = "Built-in function";
-			langDef.mIdentifiers.insert(std::make_pair(std::string(k), id));
-		}
-
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\\'[^\\\']*\\\'", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation));
-
-		langDef.mCommentStart = "/*";
-		langDef.mCommentEnd = "*/";
-		langDef.mSingleLineComment = "//";
-
-		langDef.mCaseSensitive = false;
-		langDef.mAutoIndentation = false;
-
-		langDef.mName = "SQL";
-
-		inited = true;
-	}
-	return langDef;
-}
-
-const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::AngelScript()
-{
-	static bool inited = false;
-	static LanguageDefinition langDef;
-	if (!inited)
-	{
-		static const char* const keywords[] = {
-			"and", "abstract", "auto", "bool", "break", "case", "cast", "class", "const", "continue", "default", "do", "double", "else", "enum", "false", "final", "float", "for",
-			"from", "funcdef", "function", "get", "if", "import", "in", "inout", "int", "interface", "int8", "int16", "int32", "int64", "is", "mixin", "namespace", "not",
-			"null", "or", "out", "override", "private", "protected", "return", "set", "shared", "super", "switch", "this ", "true", "typedef", "uint", "uint8", "uint16", "uint32",
-			"uint64", "void", "while", "xor"
-		};
-
-		for (auto& k : keywords)
-			langDef.mKeywords.insert(k);
-
-		static const char* const identifiers[] = {
-			"cos", "sin", "tab", "acos", "asin", "atan", "atan2", "cosh", "sinh", "tanh", "log", "log10", "pow", "sqrt", "abs", "ceil", "floor", "fraction", "closeTo", "fpFromIEEE", "fpToIEEE",
-			"complex", "opEquals", "opAddAssign", "opSubAssign", "opMulAssign", "opDivAssign", "opAdd", "opSub", "opMul", "opDiv"
-		};
-		for (auto& k : identifiers)
-		{
-			Identifier id;
-			id.mDeclaration = "Built-in function";
-			langDef.mIdentifiers.insert(std::make_pair(std::string(k), id));
-		}
-
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\'\\\\?[^\\']\\'", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation));
-
-		langDef.mCommentStart = "/*";
-		langDef.mCommentEnd = "*/";
-		langDef.mSingleLineComment = "//";
-
-		langDef.mCaseSensitive = true;
-		langDef.mAutoIndentation = true;
-
-		langDef.mName = "AngelScript";
-
-		inited = true;
-	}
-	return langDef;
-}
-
-const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::Lua()
-{
-	static bool inited = false;
-	static LanguageDefinition langDef;
-	if (!inited)
-	{
-		static const char* const keywords[] = {
-			"and", "break", "do", "", "else", "elseif", "end", "false", "for", "function", "if", "in", "", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while"
-		};
-
-		for (auto& k : keywords)
-			langDef.mKeywords.insert(k);
-
-		static const char* const identifiers[] = {
-			"assert", "collectgarbage", "dofile", "error", "getmetatable", "ipairs", "loadfile", "load", "loadstring",  "next",  "pairs",  "pcall",  "print",  "rawequal",  "rawlen",  "rawget",  "rawset",
-			"select",  "setmetatable",  "tonumber",  "tostring",  "type",  "xpcall",  "_G",  "_VERSION","arshift", "band", "bnot", "bor", "bxor", "btest", "extract", "lrotate", "lshift", "replace",
-			"rrotate", "rshift", "create", "resume", "running", "status", "wrap", "yield", "isyieldable", "debug","getuservalue", "gethook", "getinfo", "getlocal", "getregistry", "getmetatable",
-			"getupvalue", "upvaluejoin", "upvalueid", "setuservalue", "sethook", "setlocal", "setmetatable", "setupvalue", "traceback", "close", "flush", "input", "lines", "open", "output", "popen",
-			"read", "tmpfile", "type", "write", "close", "flush", "lines", "read", "seek", "setvbuf", "write", "__gc", "__tostring", "abs", "acos", "asin", "atan", "ceil", "cos", "deg", "exp", "tointeger",
-			"floor", "fmod", "ult", "log", "max", "min", "modf", "rad", "random", "randomseed", "sin", "sqrt", "string", "tan", "type", "atan2", "cosh", "sinh", "tanh",
-			"pow", "frexp", "ldexp", "log10", "pi", "huge", "maxinteger", "mininteger", "loadlib", "searchpath", "seeall", "preload", "cpath", "path", "searchers", "loaded", "module", "require", "clock",
-			"date", "difftime", "execute", "exit", "getenv", "remove", "rename", "setlocale", "time", "tmpname", "byte", "char", "dump", "find", "format", "gmatch", "gsub", "len", "lower", "match", "rep",
-			"reverse", "sub", "upper", "pack", "packsize", "unpack", "concat", "maxn", "insert", "pack", "unpack", "remove", "move", "sort", "offset", "codepoint", "char", "len", "codes", "charpattern",
-			"coroutine", "table", "io", "os", "string", "utf8", "bit32", "math", "debug", "package"
-		};
-		for (auto& k : identifiers)
-		{
-			Identifier id;
-			id.mDeclaration = "Built-in function";
-			langDef.mIdentifiers.insert(std::make_pair(std::string(k), id));
-		}
-
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\\'[^\\\']*\\\'", PaletteIndex::String));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier));
-		langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation));
-
-		langDef.mCommentStart = "--[[";
-		langDef.mCommentEnd = "]]";
-		langDef.mSingleLineComment = "--";
-
-		langDef.mCaseSensitive = true;
-		langDef.mAutoIndentation = false;
-
-		langDef.mName = "Lua";
-
-		inited = true;
-	}
-	return langDef;
-}
diff --git a/source/imgui/TextEditor.h b/source/imgui/TextEditor.h
index bd52e13..e0e86cd 100644
--- a/source/imgui/TextEditor.h
+++ b/source/imgui/TextEditor.h
@@ -174,12 +174,6 @@ public:
 		}
 
 		static const LanguageDefinition& CPlusPlus();
-		static const LanguageDefinition& HLSL();
-		static const LanguageDefinition& GLSL();
-		static const LanguageDefinition& C();
-		static const LanguageDefinition& SQL();
-		static const LanguageDefinition& AngelScript();
-		static const LanguageDefinition& Lua();
 	};
 
 	TextEditor();
diff --git a/source/imgui/imgui.h b/source/imgui/imgui.h
index 182c46a..8d2b376 100644
--- a/source/imgui/imgui.h
+++ b/source/imgui/imgui.h
@@ -243,9 +243,9 @@ typedef unsigned long long  ImU64;  // 64-bit unsigned integer (post C++11)
 IM_MSVC_RUNTIME_CHECKS_OFF
 struct ImVec2
 {
-    float                                   x, y;
-    ImVec2()                                { x = y = 0.0f; }
-    ImVec2(float _x, float _y)              { x = _x; y = _y; }
+    float                                   x = 0.f, y = 0.f;
+    constexpr ImVec2()                      = default;
+    constexpr ImVec2(float _x, float _y)    : x(_x), y(_y) {}
     float  operator[] (size_t idx) const    { IM_ASSERT(idx <= 1); return (&x)[idx]; }    // We very rarely use this [] operator, the assert overhead is fine.
     float& operator[] (size_t idx)          { IM_ASSERT(idx <= 1); return (&x)[idx]; }    // We very rarely use this [] operator, the assert overhead is fine.
 #ifdef IM_VEC2_CLASS_EXTRA
diff --git a/source/logview.cpp b/source/logview.cpp
new file mode 100644
index 0000000..267cecb
--- /dev/null
+++ b/source/logview.cpp
@@ -0,0 +1,82 @@
+#include "logview.h"
+
+LogView::LogView()
+{
+    Clear();
+}
+
+void LogView::Clear()
+{
+    Buf.clear();
+    LineOffsets.clear();
+    LineOffsets.push_back(0);
+    updated = false;
+}
+
+void LogView::AddLog(const std::string& str)
+{
+    AddLog(str.c_str());
+}
+
+void LogView::AddLog(const char* fmt, ...)
+{
+    int old_size = Buf.size();
+    va_list args;
+    va_start(args, fmt);
+    Buf.appendfv(fmt, args);
+    Buf.appendfv("\n", args);
+    va_end(args);
+    for (int new_size = Buf.size(); old_size < new_size; old_size++)
+        if (Buf[old_size] == '\n')
+            LineOffsets.push_back(old_size + 1);
+    updated = true;
+}
+
+void LogView::Draw(const char* title, bool* p_open, ImGuiWindowFlags flags)
+{
+    if (!ImGui::Begin(title, p_open, flags))
+    {
+        ImGui::End();
+        return;
+    }
+
+    ImGui::Text("Log ");
+    ImGui::SameLine();
+    if (ImGui::Button("Clear"))
+        Clear();
+    ImGui::SameLine();
+    if (ImGui::Button("Copy"))
+        ImGui::LogToClipboard();
+    ImGui::Separator();
+    ImGui::BeginChild("scrolling", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);
+
+
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
+    const char* buf = Buf.begin();
+    const char* buf_end = Buf.end();
+
+    ImGuiListClipper clipper;
+    clipper.Begin(LineOffsets.Size);
+
+    while (clipper.Step())
+    {
+        for (int line_no = clipper.DisplayStart; line_no < clipper.DisplayEnd; line_no++)
+        {
+            const char* line_start = buf + LineOffsets[line_no];
+            const char* line_end = (line_no + 1 < LineOffsets.Size) ? (buf + LineOffsets[line_no + 1] - 1) : buf_end;
+            ImGui::TextUnformatted(line_start, line_end);
+        }
+    }
+    clipper.End();
+
+    ImGui::PopStyleVar();
+
+    if (updated) {
+        ImGui::SetScrollHereY();
+        updated = false;
+    }
+
+    ImGui::EndChild();
+    ImGui::End();
+}
+
diff --git a/source/logview.h b/source/logview.h
index 4ab2c94..3c6acf1 100644
--- a/source/logview.h
+++ b/source/logview.h
@@ -3,87 +3,23 @@
 
 #include <string>
 
+#include "imgui.h"
+
 // Adapted from ExampleAppLog from imgui_demo.cpp
 class LogView
 {
 public:
-    LogView()
-    {
-        Clear();
-    }
-
-    void Clear()
-    {
-        Buf.clear();
-        LineOffsets.clear();
-        LineOffsets.push_back(0);
-    }
-
-    void AddLog(const std::string& str)
-    {
-        AddLog(str.c_str());
-    }
-
-    void AddLog(const char* fmt, ...) IM_FMTARGS(2)
-    {
-        int old_size = Buf.size();
-        va_list args;
-        va_start(args, fmt);
-        Buf.appendfv(fmt, args);
-        Buf.appendfv("\n", args);
-        va_end(args);
-        for (int new_size = Buf.size(); old_size < new_size; old_size++)
-            if (Buf[old_size] == '\n')
-                LineOffsets.push_back(old_size + 1);
-    }
-
-    void Draw(const char* title, bool* p_open = NULL, ImGuiWindowFlags flags = 0)
-    {
-        if (!ImGui::Begin(title, p_open, flags))
-        {
-            ImGui::End();
-            return;
-        }
-
-        ImGui::Text("Log ");
-        ImGui::SameLine();
-        if (ImGui::Button("Clear"))
-            Clear();
-        ImGui::SameLine();
-        if (ImGui::Button("Copy"))
-            ImGui::LogToClipboard();
-        ImGui::Separator();
-        ImGui::BeginChild("scrolling", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);
-
-
-        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
-        const char* buf = Buf.begin();
-        const char* buf_end = Buf.end();
-        ImGuiListClipper clipper;
-        clipper.Begin(LineOffsets.Size);
-        while (clipper.Step())
-        {
-            for (int line_no = clipper.DisplayStart; line_no < clipper.DisplayEnd; line_no++)
-            {
-                const char* line_start = buf + LineOffsets[line_no];
-                const char* line_end = (line_no + 1 < LineOffsets.Size) ? (buf + LineOffsets[line_no + 1] - 1) : buf_end;
-                ImGui::TextUnformatted(line_start, line_end);
-            }
-        }
-        clipper.End();
-
-        ImGui::PopStyleVar();
-
-        if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
-            ImGui::SetScrollHereY(1.0f);
+    LogView();
 
-        ImGui::EndChild();
-        ImGui::End();
-    }
+    void Clear();
+    void AddLog(const std::string& str);
+    void AddLog(const char* fmt, ...) IM_FMTARGS(2);
+    void Draw(const char* title, bool* p_open = NULL, ImGuiWindowFlags flags = 0);
 
 private:
     ImGuiTextBuffer Buf;
     ImVector<int> LineOffsets; // Index to lines offset. We maintain this with AddLog() calls.
+    bool updated;
 };
 
 #endif // LOGVIEW_H
diff --git a/source/main.cpp b/source/main.cpp
index 20c8ea1..5eac338 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -25,27 +25,24 @@
 extern ImFont *fontSans;
 extern ImFont *fontMono;
 
-extern bool guiInitialize();
-extern void guiHandleEvents(bool& done);
-extern void guiShutdown();
-extern void guiRender(void (*func)());
+bool guiInitialize();
+bool guiHandleEvents();
+void guiShutdown();
+void guiRender(void (*func)());
 
-extern void fileRenderMenu();
-extern void fileRenderDialog();
-extern void fileInit();
+void fileRenderMenu();
+void fileRenderDialog();
+void fileInit();
 
-extern void codeEditorInit();
-extern void codeRenderMenu();
-extern void codeRenderToolbar();
-extern void codeRenderWidgets();
+void codeEditorInit();
+void codeRenderMenu();
+void codeRenderToolbar();
+void codeRenderWidgets();
 
-extern void deviceRenderDraw();
-extern void deviceRenderMenu();
-extern void deviceRenderToolbar();
-extern void deviceRenderWidgets();
-
-// Globals that live here
-bool done = false;
+void deviceRenderDraw();
+void deviceRenderMenu();
+void deviceRenderToolbar();
+void deviceRenderWidgets();
 
 static LogView logView;
 
@@ -54,6 +51,8 @@ void log(const std::string& str)
     logView.AddLog(str);
 }
 
+static void renderWindow();
+
 int main(int, char **)
 {
     if (!guiInitialize())
@@ -62,62 +61,72 @@ int main(int, char **)
     codeEditorInit();
     fileInit();
 
-    while (!done) {
-        auto endTime = std::chrono::steady_clock::now() +
-            std::chrono::milliseconds(static_cast<unsigned int>(std::floor(1000. / 60.)));
-
-        guiHandleEvents(done);
-
-        // Start the new window frame and render the menu bar.
-        ImGui_ImplOpenGL2_NewFrame();
-        ImGui_ImplSDL2_NewFrame();
-        ImGui::NewFrame();
+    while (1) {
+        constexpr std::chrono::duration<double> fpsDelay (1. / 60.);
+        const auto endTime = std::chrono::steady_clock::now() + fpsDelay;
 
-        if (ImGui::BeginMainMenuBar()) {
-            fileRenderMenu();
-            deviceRenderMenu();
-            codeRenderMenu();
-            ImGui::EndMainMenuBar();
+        const bool isDone = guiHandleEvents();
+        if (!isDone) {
+            renderWindow();
+            std::this_thread::sleep_until(endTime);
+        } else {
+            break;
         }
+    }
 
-        // Begin the main view which the controls will be drawn onto.
-        ImGui::SetNextWindowPos({0, 22});
-        ImGui::SetNextWindowSize({WINDOW_WIDTH, WINDOW_HEIGHT - 22 - 200});
-        ImGui::Begin("main", nullptr,
-                     ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration |
-                         ImGuiWindowFlags_NoBringToFrontOnFocus);
-
-        // Render main controls (order is important).
-        {
-            ImGui::PushFont(fontSans);
-            codeRenderToolbar();
-            deviceRenderToolbar();
-            fileRenderDialog();
-            deviceRenderWidgets();
-            ImGui::PopFont();
-
-            ImGui::PushFont(fontMono);
-            codeRenderWidgets();
-            ImGui::SetNextWindowPos({0, WINDOW_HEIGHT - 200});
-            ImGui::SetNextWindowSize({WINDOW_WIDTH, 200});
-            logView.Draw("log", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoBringToFrontOnFocus);
-            ImGui::PopFont();
-        }
+    guiShutdown();
+    return 0;
+}
 
-        ImGui::End();
+void renderWindow()
+{
+    // Start the new window frame and render the menu bar.
+    ImGui_ImplOpenGL2_NewFrame();
+    ImGui_ImplSDL2_NewFrame();
+    ImGui::NewFrame();
+
+    if (ImGui::BeginMainMenuBar()) {
+        fileRenderMenu();
+        deviceRenderMenu();
+        codeRenderMenu();
+        ImGui::EndMainMenuBar();
+    }
 
-        deviceRenderDraw();
+    // Begin the main view which the controls will be drawn onto.
+    constexpr float LOGVIEW_HEIGHT = 200;
+    constexpr ImVec2 WINDOW_POS (0, 22);
+    constexpr ImVec2 WINDOW_SIZE (WINDOW_WIDTH, WINDOW_HEIGHT - 22 - LOGVIEW_HEIGHT);
+    ImGui::SetNextWindowPos(WINDOW_POS);
+    ImGui::SetNextWindowSize(WINDOW_SIZE);
+    ImGui::Begin("main", nullptr,
+                 ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration |
+                     ImGuiWindowFlags_NoBringToFrontOnFocus);
+
+    // Render main controls (order is important).
+    {
+        ImGui::PushFont(fontSans);
+        codeRenderToolbar();
+        deviceRenderToolbar();
+        fileRenderDialog();
+        deviceRenderWidgets();
+        ImGui::PopFont();
+
+        ImGui::PushFont(fontMono);
+        codeRenderWidgets();
+        ImGui::SetNextWindowPos({0, WINDOW_HEIGHT - LOGVIEW_HEIGHT});
+        ImGui::SetNextWindowSize({WINDOW_WIDTH, LOGVIEW_HEIGHT});
+        logView.Draw("log", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoBringToFrontOnFocus);
+        ImGui::PopFont();
+    }
 
-        // Draw everything to the screen.
-        ImGui::Render();
-        guiRender([] {
-            ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
-        });
+    ImGui::End();
 
-        std::this_thread::sleep_until(endTime);
-    }
+    deviceRenderDraw();
 
-    guiShutdown();
-    return 0;
+    // Draw everything to the screen.
+    ImGui::Render();
+    guiRender([] {
+        ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
+    });
 }
 
-- 
cgit v1.2.3


From 1b176cf6cd75c8031a140961655cdd3c16589a68 Mon Sep 17 00:00:00 2001
From: Clyne Sullivan <clyne@bitgloo.com>
Date: Sun, 9 Jan 2022 12:28:19 -0500
Subject: small changes; sig gen square(), triangle(), pulse()

---
 examples/1_convolve_simple.cpp        |  29 +++
 examples/2_convolve_overlap_save.cpp  |  47 ++++
 examples/3_fir.cpp                    |  47 ++++
 examples/4_fir_pro.cpp                | 478 ++++++++++++++++++++++++++++++++++
 examples/5_fir_differentiator.cpp     |  30 +++
 examples/6_iir_test.cpp               |  13 +
 examples/7_iir_echo.cpp               |  22 ++
 source/circular.hpp                   |  11 +
 source/code.cpp                       |  26 +-
 source/device.cpp                     |  18 +-
 source/device_formula.cpp             |  44 +++-
 source/file.cpp                       |  12 +-
 source/gui.cpp                        |  49 ++--
 source/gui_code.cpp                   |   4 +-
 source/gui_device.cpp                 |  33 ++-
 source/imgui/TextEditor.cpp           |   2 +-
 source/logview.cpp                    |   2 +-
 source/main.cpp                       |  48 ++--
 templates/1_convolve_simple.cpp       |  29 ---
 templates/2_convolve_overlap_save.cpp |  47 ----
 templates/3_fir.cpp                   |  47 ----
 templates/4_fir_pro.cpp               | 478 ----------------------------------
 templates/5_fir_differentiator.cpp    |  30 ---
 templates/6_iir_test.cpp              |  13 -
 templates/7_iir_echo.cpp              |  22 --
 25 files changed, 841 insertions(+), 740 deletions(-)
 create mode 100644 examples/1_convolve_simple.cpp
 create mode 100644 examples/2_convolve_overlap_save.cpp
 create mode 100644 examples/3_fir.cpp
 create mode 100644 examples/4_fir_pro.cpp
 create mode 100644 examples/5_fir_differentiator.cpp
 create mode 100644 examples/6_iir_test.cpp
 create mode 100644 examples/7_iir_echo.cpp
 delete mode 100644 templates/1_convolve_simple.cpp
 delete mode 100644 templates/2_convolve_overlap_save.cpp
 delete mode 100644 templates/3_fir.cpp
 delete mode 100644 templates/4_fir_pro.cpp
 delete mode 100644 templates/5_fir_differentiator.cpp
 delete mode 100644 templates/6_iir_test.cpp
 delete mode 100644 templates/7_iir_echo.cpp

(limited to 'source/file.cpp')

diff --git a/examples/1_convolve_simple.cpp b/examples/1_convolve_simple.cpp
new file mode 100644
index 0000000..8de05d3
--- /dev/null
+++ b/examples/1_convolve_simple.cpp
@@ -0,0 +1,29 @@
+/**
+ * 1_convolve_simple.cpp
+ * Written by Clyne Sullivan.
+ *
+ * Computes a convolution in the simplest way possible. While the code is brief, it lacks many
+ * possible optimizations. The convolution's result will not fill the output buffer either, as the
+ * transient response is not calculated.
+ */
+
+Sample *process_data(Samples samples)
+{
+    // Define our output buffer. SIZE is the largest size of the 'samples' buffer.
+    static Sample buffer[samples.size()];
+
+    // Define our filter
+    constexpr unsigned int filter_size = 3;
+	float filter[filter_size] = {
+        0.3333, 0.3333, 0.3333
+    };
+
+    // Begin convolving:
+    for (int n = 0; n < samples.size() - (filter_size - 1); n++) {
+        buffer[n] = 0;
+        for (int k = 0; k < filter_size; k++)
+            buffer[n] += samples[n + k] * filter[k];
+    }
+
+    return buffer;
+}
diff --git a/examples/2_convolve_overlap_save.cpp b/examples/2_convolve_overlap_save.cpp
new file mode 100644
index 0000000..57c020a
--- /dev/null
+++ b/examples/2_convolve_overlap_save.cpp
@@ -0,0 +1,47 @@
+/**
+ * 2_convolve_overlap_save.cpp
+ * Written by Clyne Sullivan.
+ *
+ * This convolution examples takes an overlap-save approach, where samples from the previous run
+ * are saved so that the overall operation is not interrupted (i.e. the observed output will
+ * transition smoothly between processed "chunks").
+ *
+ * Note that there are still improvements that can be made to the code; for example, notice every
+ * spot where an integer/float conversion is necessary. Operations like these may slow down the
+ * computation.
+ */
+
+Sample *process_data(Samples samples)
+{
+    static Sample buffer[samples.size()];
+
+    constexpr unsigned int filter_size = 3;
+	float filter[filter_size] = {
+        0.3333, 0.3333, 0.3333
+    };
+
+    // Keep a buffer of extra samples for overlap-save
+    static Sample prev[filter_size];
+
+    for (int n = 0; n < samples.size(); n++) {
+        buffer[n] = 0;
+
+        for (int k = 0; k < filter_size; k++) {
+            int i = n - (filter_size - 1) + k;
+
+            // If i is >= 0, access current sample buffer.
+            // If i is < 0, provide the previous samples from the 'prev' buffer
+            if (i >= 0)
+                buffer[n] += samples[i] * filter[k];
+            else
+                buffer[n] += prev[filter_size - 1 + i] * filter[k];
+        }
+    }
+
+    // Save samples for the next convolution run
+    for (int i = 0; i < filter_size; i++)
+        prev[i] = samples[samples.size() - filter_size + i];
+
+    return buffer;
+}
+
diff --git a/examples/3_fir.cpp b/examples/3_fir.cpp
new file mode 100644
index 0000000..3a68500
--- /dev/null
+++ b/examples/3_fir.cpp
@@ -0,0 +1,47 @@
+/**
+ * 3_fir.cpp
+ * Written by Clyne Sullivan.
+ *
+ * The below code was written for applying FIR filters. While this is still essentially an overlap-
+ * save convolution, other optimizations have been made to allow for larger filters to be applied
+ * within the available execution time. Samples are also normalized so that they center around zero.
+ */
+
+Sample *process_data(Samples samples)
+{
+    static Sample buffer[samples.size()];
+
+	// Define the filter:
+	constexpr unsigned int filter_size = 3;
+	static float filter[filter_size] = {
+        // Put filter values here (note: precision will be truncated for 'float' size).
+        0.3333, 0.3333, 0.3333
+	};
+
+    // Do an overlap-save convolution
+    static Sample prev[filter_size];
+
+    for (int n = 0; n < samples.size(); n++) {
+        // Using a float variable for accumulation allows for better code optimization
+        float v = 0;
+
+        for (int k = 0; k < filter_size; k++) {
+            int i = n - (filter_size - 1) + k;
+
+            auto s = i >= 0 ? samples[i] : prev[filter_size - 1 + i];
+			// Sample values are 0 to 4095. Below, the original sample is normalized to a -1.0 to
+            // 1.0 range for calculation.
+            v += (s / 2048.f - 1) * filter[k];
+        }
+
+        // Return value to sample range of 0-4095.
+        buffer[n] = (v + 1) * 2048.f;
+    }
+
+    // Save samples for next convolution
+    for (int i = 0; i < filter_size; i++)
+        prev[i] = samples[samples.size() - filter_size + i];
+
+    return buffer;
+}
+
diff --git a/examples/4_fir_pro.cpp b/examples/4_fir_pro.cpp
new file mode 100644
index 0000000..b1a6832
--- /dev/null
+++ b/examples/4_fir_pro.cpp
@@ -0,0 +1,478 @@
+#include <cstdint>
+using float32_t = float;
+
+typedef struct
+{
+    uint16_t numTaps;     /**< number of filter coefficients in the filter. */
+    float32_t *pState;    /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+    float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */
+} arm_fir_instance_f32;
+
+static void arm_fir_f32(const arm_fir_instance_f32 * S, float32_t * pSrc, float32_t * pDst, uint32_t blockSize);
+
+Sample *process_data(Samples samples)
+{
+	// 1. Define our array sizes (Be sure to set Run > Set buffer size... to below value!)
+	constexpr unsigned int buffer_size = 500;
+	constexpr unsigned int filter_size = 100;
+
+	// 2. Define our filter and the working arrays
+	static float filter[filter_size] = {
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
+		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f
+	};
+	static float input[buffer_size];
+	static float output[buffer_size];
+	static float working[buffer_size + filter_size];
+
+	// 3. Scale 0-4095 interger sample values to +/- 1.0 floats
+	for (unsigned int i = 0; i < samples.size(); i++)
+		input[i] = (samples[i] - 2048) / 2048.f;
+
+	// 4. Compute the FIR
+	arm_fir_instance_f32 fir { filter_size, working, filter };
+	arm_fir_f32(&fir, input, output, samples.size());
+
+	// 5. Convert float results back to 0-4095 range for output
+	for (unsigned int i = 0; i < samples.size(); i++)
+		samples[i] = output[i] * 2048.f + 2048;
+
+    return samples.data();
+}
+
+// Below taken from the CMSIS DSP Library (find it on GitHub)
+void arm_fir_f32(
+	const arm_fir_instance_f32 * S,
+	float32_t * pSrc,
+	float32_t * pDst,
+	uint32_t blockSize)
+{
+   float32_t *pState = S->pState;                 /* State pointer */
+   float32_t *pCoeffs = S->pCoeffs;               /* Coefficient pointer */
+   float32_t *pStateCurnt;                        /* Points to the current sample of the state */
+   float32_t *px, *pb;                            /* Temporary pointers for state and coefficient buffers */
+   float32_t acc0, acc1, acc2, acc3, acc4, acc5, acc6, acc7;     /* Accumulators */
+   float32_t x0, x1, x2, x3, x4, x5, x6, x7, c0;  /* Temporary variables to hold state and coefficient values */
+   uint32_t numTaps = S->numTaps;                 /* Number of filter coefficients in the filter */
+   uint32_t i, tapCnt, blkCnt;                    /* Loop counters */
+   float32_t p0,p1,p2,p3,p4,p5,p6,p7;             /* Temporary product values */
+
+   /* S->pState points to state array which contains previous frame (numTaps - 1) samples */
+   /* pStateCurnt points to the location where the new input data should be written */
+   pStateCurnt = &(S->pState[(numTaps - 1u)]);
+
+   /* Apply loop unrolling and compute 8 output values simultaneously.  
+    * The variables acc0 ... acc7 hold output values that are being computed:  
+    *  
+    *    acc0 =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0]  
+    *    acc1 =  b[numTaps-1] * x[n-numTaps] +   b[numTaps-2] * x[n-numTaps-1] + b[numTaps-3] * x[n-numTaps-2] +...+ b[0] * x[1]  
+    *    acc2 =  b[numTaps-1] * x[n-numTaps+1] + b[numTaps-2] * x[n-numTaps] +   b[numTaps-3] * x[n-numTaps-1] +...+ b[0] * x[2]  
+    *    acc3 =  b[numTaps-1] * x[n-numTaps+2] + b[numTaps-2] * x[n-numTaps+1] + b[numTaps-3] * x[n-numTaps]   +...+ b[0] * x[3]  
+    */
+   blkCnt = blockSize >> 3;
+
+   /* First part of the processing with loop unrolling.  Compute 8 outputs at a time.  
+   ** a second loop below computes the remaining 1 to 7 samples. */
+   while(blkCnt > 0u)
+   {
+      /* Copy four new input samples into the state buffer */
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+
+      /* Set all accumulators to zero */
+      acc0 = 0.0f;
+      acc1 = 0.0f;
+      acc2 = 0.0f;
+      acc3 = 0.0f;
+      acc4 = 0.0f;
+      acc5 = 0.0f;
+      acc6 = 0.0f;
+      acc7 = 0.0f;		
+
+      /* Initialize state pointer */
+      px = pState;
+
+      /* Initialize coeff pointer */
+      pb = (pCoeffs);		
+   
+      /* This is separated from the others to avoid 
+       * a call to __aeabi_memmove which would be slower
+       */
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+      *pStateCurnt++ = *pSrc++;
+
+      /* Read the first seven samples from the state buffer:  x[n-numTaps], x[n-numTaps-1], x[n-numTaps-2] */
+      x0 = *px++;
+      x1 = *px++;
+      x2 = *px++;
+      x3 = *px++;
+      x4 = *px++;
+      x5 = *px++;
+      x6 = *px++;
+
+      /* Loop unrolling.  Process 8 taps at a time. */
+      tapCnt = numTaps >> 3u;
+      
+      /* Loop over the number of taps.  Unroll by a factor of 8.  
+       ** Repeat until we've computed numTaps-8 coefficients. */
+      while(tapCnt > 0u)
+      {
+         /* Read the b[numTaps-1] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-3] sample */
+         x7 = *(px++);
+
+         /* acc0 +=  b[numTaps-1] * x[n-numTaps] */
+         p0 = x0 * c0;
+
+         /* acc1 +=  b[numTaps-1] * x[n-numTaps-1] */
+         p1 = x1 * c0;
+
+         /* acc2 +=  b[numTaps-1] * x[n-numTaps-2] */
+         p2 = x2 * c0;
+
+         /* acc3 +=  b[numTaps-1] * x[n-numTaps-3] */
+         p3 = x3 * c0;
+
+         /* acc4 +=  b[numTaps-1] * x[n-numTaps-4] */
+         p4 = x4 * c0;
+
+         /* acc1 +=  b[numTaps-1] * x[n-numTaps-5] */
+         p5 = x5 * c0;
+
+         /* acc2 +=  b[numTaps-1] * x[n-numTaps-6] */
+         p6 = x6 * c0;
+
+         /* acc3 +=  b[numTaps-1] * x[n-numTaps-7] */
+         p7 = x7 * c0;
+         
+         /* Read the b[numTaps-2] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-4] sample */
+         x0 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+
+         /* Perform the multiply-accumulate */
+         p0 = x1 * c0;
+         p1 = x2 * c0;   
+         p2 = x3 * c0;   
+         p3 = x4 * c0;   
+         p4 = x5 * c0;   
+         p5 = x6 * c0;   
+         p6 = x7 * c0;   
+         p7 = x0 * c0;   
+         
+         /* Read the b[numTaps-3] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-5] sample */
+         x1 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x2 * c0;
+         p1 = x3 * c0;   
+         p2 = x4 * c0;   
+         p3 = x5 * c0;   
+         p4 = x6 * c0;   
+         p5 = x7 * c0;   
+         p6 = x0 * c0;   
+         p7 = x1 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x2 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x3 * c0;
+         p1 = x4 * c0;   
+         p2 = x5 * c0;   
+         p3 = x6 * c0;   
+         p4 = x7 * c0;   
+         p5 = x0 * c0;   
+         p6 = x1 * c0;   
+         p7 = x2 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x3 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x4 * c0;
+         p1 = x5 * c0;   
+         p2 = x6 * c0;   
+         p3 = x7 * c0;   
+         p4 = x0 * c0;   
+         p5 = x1 * c0;   
+         p6 = x2 * c0;   
+         p7 = x3 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x4 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x5 * c0;
+         p1 = x6 * c0;   
+         p2 = x7 * c0;   
+         p3 = x0 * c0;   
+         p4 = x1 * c0;   
+         p5 = x2 * c0;   
+         p6 = x3 * c0;   
+         p7 = x4 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x5 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x6 * c0;
+         p1 = x7 * c0;   
+         p2 = x0 * c0;   
+         p3 = x1 * c0;   
+         p4 = x2 * c0;   
+         p5 = x3 * c0;   
+         p6 = x4 * c0;   
+         p7 = x5 * c0;   
+
+         /* Read the b[numTaps-4] coefficient */
+         c0 = *(pb++);
+
+         /* Read x[n-numTaps-6] sample */
+         x6 = *(px++);
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Perform the multiply-accumulates */      
+         p0 = x7 * c0;
+         p1 = x0 * c0;   
+         p2 = x1 * c0;   
+         p3 = x2 * c0;   
+         p4 = x3 * c0;   
+         p5 = x4 * c0;   
+         p6 = x5 * c0;   
+         p7 = x6 * c0;   
+
+         tapCnt--;
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+      }
+
+      /* If the filter length is not a multiple of 8, compute the remaining filter taps */
+      tapCnt = numTaps % 0x8u;
+
+      while(tapCnt > 0u)
+      {
+         /* Read coefficients */
+         c0 = *(pb++);
+
+         /* Fetch 1 state variable */
+         x7 = *(px++);
+
+         /* Perform the multiply-accumulates */      
+         p0 = x0 * c0;
+         p1 = x1 * c0;   
+         p2 = x2 * c0;   
+         p3 = x3 * c0;   
+         p4 = x4 * c0;   
+         p5 = x5 * c0;   
+         p6 = x6 * c0;   
+         p7 = x7 * c0;   
+
+         /* Reuse the present sample states for next sample */
+         x0 = x1;
+         x1 = x2;
+         x2 = x3;
+         x3 = x4;
+         x4 = x5;
+         x5 = x6;
+         x6 = x7;
+         
+         acc0 += p0;
+         acc1 += p1;
+         acc2 += p2;
+         acc3 += p3;
+         acc4 += p4;
+         acc5 += p5;
+         acc6 += p6;
+         acc7 += p7;
+
+         /* Decrement the loop counter */
+         tapCnt--;
+      }
+
+      /* Advance the state pointer by 8 to process the next group of 8 samples */
+      pState = pState + 8;
+
+      /* The results in the 8 accumulators, store in the destination buffer. */
+      *pDst++ = acc0;
+      *pDst++ = acc1;
+      *pDst++ = acc2;
+      *pDst++ = acc3;
+      *pDst++ = acc4;
+      *pDst++ = acc5;
+      *pDst++ = acc6;
+      *pDst++ = acc7;
+
+      blkCnt--;
+   }
+
+   /* If the blockSize is not a multiple of 8, compute any remaining output samples here.  
+   ** No loop unrolling is used. */
+   blkCnt = blockSize % 0x8u;
+
+   while(blkCnt > 0u)
+   {
+      /* Copy one sample at a time into state buffer */
+      *pStateCurnt++ = *pSrc++;
+
+      /* Set the accumulator to zero */
+      acc0 = 0.0f;
+
+      /* Initialize state pointer */
+      px = pState;
+
+      /* Initialize Coefficient pointer */
+      pb = (pCoeffs);
+
+      i = numTaps;
+
+      /* Perform the multiply-accumulates */
+      do
+      {
+         acc0 += *px++ * *pb++;
+         i--;
+
+      } while(i > 0u);
+
+      /* The result is store in the destination buffer. */
+      *pDst++ = acc0;
+
+      /* Advance state pointer by 1 for the next sample */
+      pState = pState + 1;
+
+      blkCnt--;
+   }
+
+   /* Processing is complete.  
+   ** Now copy the last numTaps - 1 samples to the start of the state buffer.  
+   ** This prepares the state buffer for the next function call. */
+
+   /* Points to the start of the state buffer */
+   pStateCurnt = S->pState;
+
+   tapCnt = (numTaps - 1u) >> 2u;
+
+   /* copy data */
+   while(tapCnt > 0u)
+   {
+      *pStateCurnt++ = *pState++;
+      *pStateCurnt++ = *pState++;
+      *pStateCurnt++ = *pState++;
+      *pStateCurnt++ = *pState++;
+
+      /* Decrement the loop counter */
+      tapCnt--;
+   }
+
+   /* Calculate remaining number of copies */
+   tapCnt = (numTaps - 1u) % 0x4u;
+
+   /* Copy the remaining q31_t data */
+   while(tapCnt > 0u)
+   {
+      *pStateCurnt++ = *pState++;
+
+      /* Decrement the loop counter */
+      tapCnt--;
+   }
+}
diff --git a/examples/5_fir_differentiator.cpp b/examples/5_fir_differentiator.cpp
new file mode 100644
index 0000000..72415c6
--- /dev/null
+++ b/examples/5_fir_differentiator.cpp
@@ -0,0 +1,30 @@
+/**
+ * 5_fir_differentiator.cpp
+ * Written by Clyne Sullivan.
+ *
+ * Does an FIR differentiation on the incoming signal, so that the output is representative of the
+ * rate of change of the input.
+ * A scaling factor is applied so that the output's form is more clearly visible.
+ */
+
+Sample *process_data(Samples samples)
+{
+    constexpr int scaling_factor = 4;
+	static Sample output[samples.size()];
+    static Sample prev = 2048;
+
+    // Compute the first output value using the saved sample.
+    output[0] = 2048 + ((samples[0] - prev) * scaling_factor);
+
+	for (unsigned int i = 1; i < samples.size(); i++) {
+        // Take the rate of change and scale it.
+        // 2048 is added as the output should be centered in the voltage range.
+		output[i] = 2048 + ((samples[i] - samples[i - 1]) * scaling_factor);
+    }
+
+	// Save the last sample for the next iteration.
+    prev = samples[samples.size() - 1];
+
+    return output;
+}
+
diff --git a/examples/6_iir_test.cpp b/examples/6_iir_test.cpp
new file mode 100644
index 0000000..116a680
--- /dev/null
+++ b/examples/6_iir_test.cpp
@@ -0,0 +1,13 @@
+Sample *process_data(Samples samples)
+{
+	constexpr float alpha = 0.7;
+
+	static Sample prev = 2048;
+
+	samples[0] = (1 - alpha) * samples[0] + alpha * prev;
+	for (unsigned int i = 1; i < samples.size(); i++)
+		samples[i] = (1 - alpha) * samples[i] + alpha * samples[i - 1];
+	prev = samples[samples.size() - 1];
+
+	return samples.data();
+}
diff --git a/examples/7_iir_echo.cpp b/examples/7_iir_echo.cpp
new file mode 100644
index 0000000..57e5605
--- /dev/null
+++ b/examples/7_iir_echo.cpp
@@ -0,0 +1,22 @@
+Sample *process_data(Samples samples)
+{
+	constexpr float alpha = 0.75;
+	constexpr unsigned int D = 100;
+
+	static Sample output[samples.size()];
+	static Sample prev[D]; // prev[0] = output[0 - D]
+
+	// Do calculations with previous output
+	for (unsigned int i = 0; i < D; i++)
+		output[i] = samples[i] + alpha * (prev[i] - 2048);
+
+	// Do calculations with current samples
+	for (unsigned int i = D; i < samples.size(); i++)
+		output[i] = samples[i] + alpha * (output[i - D] - 2048);
+
+	// Save outputs for next computation
+	for (unsigned int i = 0; i < D; i++)
+		prev[i] = output[samples.size() - (D - i)];
+
+	return output;
+}
diff --git a/source/circular.hpp b/source/circular.hpp
index 33b8ee0..6b82068 100644
--- a/source/circular.hpp
+++ b/source/circular.hpp
@@ -1,3 +1,14 @@
+/**
+ * @file circular.hpp
+ * @brief Small utility for filling a buffer in a circular manner.
+ *
+ * Copyright (C) 2021 Clyne Sullivan
+ *
+ * Distributed under the GNU GPL v3 or later. You should have received a copy of
+ * the GNU General Public License along with this program.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 #ifndef CIRCULAR_HPP
 #define CIRCULAR_HPP
 
diff --git a/source/code.cpp b/source/code.cpp
index 7a9afaa..14f603c 100644
--- a/source/code.cpp
+++ b/source/code.cpp
@@ -1,3 +1,14 @@
+/**
+ * @file code.cpp
+ * @brief Functionality for compiling and disassembling source code.
+ *
+ * Copyright (C) 2021 Clyne Sullivan
+ *
+ * Distributed under the GNU GPL v3 or later. You should have received a copy of
+ * the GNU General Public License along with this program.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 #include "stmdsp.hpp"
 #include "stmdsp_code.hpp"
 
@@ -9,10 +20,13 @@
 #include <string>
 
 extern std::shared_ptr<stmdsp::device> m_device;
-extern void log(const std::string& str);
+void log(const std::string& str);
 
-std::string tempFileName; // device.cpp
+std::ifstream compileOpenBinaryFile();
+void compileEditorCode(const std::string& code);
+void disassembleCode();
 
+static std::string tempFileName;
 static std::string newTempFileName();
 static bool codeExecuteCommand(
     const std::string& command,
@@ -22,6 +36,14 @@ static void stringReplaceAll(
     const std::string& what,
     const std::string& with);
 
+std::ifstream compileOpenBinaryFile()
+{
+    if (!tempFileName.empty())
+        return std::ifstream(tempFileName + ".o");
+    else
+        return std::ifstream();
+}
+
 void compileEditorCode(const std::string& code)
 {
     log("Compiling...");
diff --git a/source/device.cpp b/source/device.cpp
index abcc88a..11e181e 100644
--- a/source/device.cpp
+++ b/source/device.cpp
@@ -30,9 +30,9 @@
 #include <thread>
 #include <vector>
 
-extern std::string tempFileName;
 extern void log(const std::string& str);
 extern std::vector<stmdsp::dacsample_t> deviceGenLoadFormulaEval(const std::string&);
+extern std::ifstream compileOpenBinaryFile();
 
 std::shared_ptr<stmdsp::device> m_device;
 
@@ -224,15 +224,21 @@ void deviceLoadLogFile(const std::string& file)
 bool deviceGenStartToggle()
 {
     if (m_device) {
-        bool running = m_device->is_siggening();
+        const bool running = m_device->is_siggening();
+
         if (!running) {
-            if (wavOutput.valid())
+            if (wavOutput.valid()) {
                 std::thread(feedSigGenTask, m_device).detach();
-            else
+            } else {
+                std::scoped_lock dlock (mutexDeviceLoad);
                 m_device->siggen_start();
+            }
             log("Generator started.");
         } else {
-            m_device->siggen_stop();
+            {
+                std::scoped_lock dlock (mutexDeviceLoad);
+                m_device->siggen_stop();
+            }
             log("Generator stopped.");
         }
 
@@ -332,7 +338,7 @@ void deviceAlgorithmUpload()
         log("No device connected.");
     } else if (m_device->is_running()) {
         log("Cannot upload algorithm while running.");
-    } else if (std::ifstream algo (tempFileName + ".o"); algo.is_open()) {
+    } else if (auto algo = compileOpenBinaryFile(); algo.is_open()) {
         std::ostringstream sstr;
         sstr << algo.rdbuf();
         auto str = sstr.str();
diff --git a/source/device_formula.cpp b/source/device_formula.cpp
index c94eab7..a70f465 100644
--- a/source/device_formula.cpp
+++ b/source/device_formula.cpp
@@ -1,31 +1,63 @@
+/**
+ * @file device_formula.cpp
+ * @brief Function for filling generator buffer using a mathematical formula.
+ * This is kept in its own file as exprtk.hpp takes forever to compile.
+ *
+ * Copyright (C) 2021 Clyne Sullivan
+ *
+ * Distributed under the GNU GPL v3 or later. You should have received a copy of
+ * the GNU General Public License along with this program.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 #include "stmdsp.hpp"
 #include "exprtk.hpp"
 
 #include <algorithm>
+#include <random>
 #include <string_view>
 #include <vector>
 
+static std::random_device randomDevice;
+
 std::vector<stmdsp::dacsample_t> deviceGenLoadFormulaEval(const std::string& formulaString)
 {
     double x = 0;
 
     exprtk::symbol_table<double> symbol_table;
+    exprtk::function_compositor<double> compositor (symbol_table);
     exprtk::expression<double> expression;
     exprtk::parser<double> parser;
 
-    symbol_table.add_variable("x", x);
     symbol_table.add_constants();
+    symbol_table.add_variable("x", x);
+    symbol_table.add_function("random",
+        [](double l, double h) -> double {
+            return std::uniform_real_distribution<double>(l, h)(randomDevice);
+        });
+    compositor.add(exprtk::function_compositor<double>::function()
+                       .name("square")
+                       .var("X")
+                       .expression("ceil(sin(pi*X))"));
+    compositor.add(exprtk::function_compositor<double>::function()
+                       .name("triangle")
+                       .var("X")
+                       .expression("ceil(sin(pi*X))*(X-floor(X))+ceil(-sin(pi*X))*(-X-floor(-X))"));
+    compositor.add(exprtk::function_compositor<double>::function()
+                       .name("pulse")
+                       .var("L")
+                       .var("X")
+                       .expression("if(X<=L,1,0)"));
     expression.register_symbol_table(symbol_table);
     parser.compile(formulaString, expression);
 
-    std::vector<stmdsp::dacsample_t> samples (stmdsp::SAMPLES_MAX);
-
-    auto genFun = [&x, &expression] {
-        stmdsp::dacsample_t s = expression.value();
+    const auto genFun = [&x, &expression] {
+        const auto s = std::clamp(expression.value(), -1., 1.) * 2048. + 2048.;
         ++x;
-        return s;
+        return static_cast<stmdsp::dacsample_t>(std::min(s, 4095.));
     };
 
+    std::vector<stmdsp::dacsample_t> samples (stmdsp::SAMPLES_MAX);
     std::generate(samples.begin(), samples.end(), genFun);
     return samples;
 }
diff --git a/source/file.cpp b/source/file.cpp
index a5ef1d8..fe5dafb 100644
--- a/source/file.cpp
+++ b/source/file.cpp
@@ -40,7 +40,7 @@ enum class FileAction {
 
 static FileAction fileAction = FileAction::None;
 static std::string fileCurrentPath;
-static std::vector<std::filesystem::path> fileTemplateList;
+static std::vector<std::filesystem::path> fileExampleList;
 
 static void saveCurrentFile()
 {
@@ -66,9 +66,9 @@ static void openNewFile()
     editor.SetText(stmdsp::file_content);
 }
 
-static std::vector<std::filesystem::path> fileScanTemplates()
+static std::vector<std::filesystem::path> fileScanExamples()
 {
-    const auto path = std::filesystem::current_path() / "templates";
+    const auto path = std::filesystem::current_path() / "examples";
     const std::filesystem::recursive_directory_iterator rdi (path);
 
     std::vector<std::filesystem::path> list;
@@ -83,7 +83,7 @@ static std::vector<std::filesystem::path> fileScanTemplates()
 
 void fileInit()
 {
-    fileTemplateList = fileScanTemplates();
+    fileExampleList = fileScanExamples();
     openNewFile();
 }
 
@@ -102,8 +102,8 @@ void fileRenderMenu()
                 "ChooseFileOpenSave", "Choose File", ".cpp", ".");
         }
 
-        if (ImGui::BeginMenu("Open Template")) {
-            for (const auto& file : fileTemplateList) {
+        if (ImGui::BeginMenu("Open Example")) {
+            for (const auto& file : fileExampleList) {
                 if (ImGui::MenuItem(file.filename().c_str())) {
                     fileCurrentPath = file.string();
                     openCurrentFile();
diff --git a/source/gui.cpp b/source/gui.cpp
index 515d471..80120c4 100644
--- a/source/gui.cpp
+++ b/source/gui.cpp
@@ -19,15 +19,17 @@
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_opengl.h>
 
-ImFont *fontSans = nullptr;
-ImFont *fontMono = nullptr;
-static ImGuiIO *io = nullptr;
+bool guiInitialize();
+void guiRender();
+bool guiHandleEvents();
+void guiShutdown();
+
 static SDL_Window *window = nullptr;
-static decltype(SDL_GL_CreateContext(nullptr)) gl_context;
+static SDL_GLContext gl_context;
 
 bool guiInitialize()
 {
-    if (SDL_Init(/*SDL_INIT_VIDEO*/0) != 0) {
+    if (SDL_Init(0) != 0) {
         printf("Error: %s\n", SDL_GetError());
         return false;
     }
@@ -42,6 +44,12 @@ bool guiInitialize()
         SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
         WINDOW_WIDTH, WINDOW_HEIGHT,
         SDL_WINDOW_OPENGL /*| SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI*/);
+
+    if (window == nullptr) {
+        puts("Error: Could not create the window!");
+        return false;
+    }
+
     gl_context = SDL_GL_CreateContext(window);
     SDL_GL_MakeCurrent(window, gl_context);
     SDL_GL_SetSwapInterval(1); // Enable vsync
@@ -49,10 +57,7 @@ bool guiInitialize()
     // Setup Dear ImGui context
     IMGUI_CHECKVERSION();
     ImGui::CreateContext();
-    io = &ImGui::GetIO();
     //io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
-    fontSans = io->Fonts->AddFontFromFileTTF("fonts/Roboto-Regular.ttf", 20);
-    fontMono = io->Fonts->AddFontFromFileTTF("fonts/RobotoMono-Regular.ttf", 20);
 
     ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
     ImGui_ImplOpenGL2_Init();
@@ -99,13 +104,19 @@ bool guiInitialize()
     return true;
 }
 
-void guiRender(void (*func)())
+void guiRender()
 {
-   glViewport(0, 0, (int)io->DisplaySize.x, (int)io->DisplaySize.y);
-   glClearColor(1, 1, 1, 1);
-   glClear(GL_COLOR_BUFFER_BIT);
-   func();
-   SDL_GL_SwapWindow(window);
+    ImGui::Render();
+
+    const auto& displaySize = ImGui::GetIO().DisplaySize;
+    const int sizeX = static_cast<int>(displaySize.x);
+    const int sizeY = static_cast<int>(displaySize.y);
+
+    glViewport(0, 0, sizeX, sizeY);
+    glClearColor(1, 1, 1, 1);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
+    SDL_GL_SwapWindow(window);
 }
 
 bool guiHandleEvents()
@@ -114,10 +125,14 @@ bool guiHandleEvents()
 
     for (SDL_Event event; SDL_PollEvent(&event);) {
         ImGui_ImplSDL2_ProcessEvent(&event);
-        if (event.type == SDL_QUIT)
-            done = true;
-        if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
+        if (event.type == SDL_QUIT) {
             done = true;
+        } else if (event.type == SDL_WINDOWEVENT) {
+            const auto& ew = event.window;
+            const auto wid = SDL_GetWindowID(window);
+            if (ew.event == SDL_WINDOWEVENT_CLOSE && ew.windowID == wid)
+                done = true;
+        }
     }
 
     return done;
diff --git a/source/gui_code.cpp b/source/gui_code.cpp
index 6917c72..19fa572 100644
--- a/source/gui_code.cpp
+++ b/source/gui_code.cpp
@@ -37,9 +37,9 @@ void codeEditorInit()
 void codeRenderMenu()
 {
     if (ImGui::BeginMenu("Code")) {
-        if (ImGui::MenuItem("Compile code"))
+        if (ImGui::MenuItem("Compile"))
             codeCompile();
-        if (ImGui::MenuItem("Show disassembly"))
+        if (ImGui::MenuItem("Disassemble"))
             codeDisassemble();
 
         ImGui::EndMenu();
diff --git a/source/gui_device.cpp b/source/gui_device.cpp
index a1d0555..43c0a58 100644
--- a/source/gui_device.cpp
+++ b/source/gui_device.cpp
@@ -55,7 +55,7 @@ void deviceRenderMenu()
         }
     };
 
-    if (ImGui::BeginMenu("Run")) {
+    if (ImGui::BeginMenu("Device")) {
         static std::string connectLabel ("Connect");
         addMenuItem(connectLabel, !m_device || !m_device->is_running(), [&] {
                 if (deviceConnect()) {
@@ -199,11 +199,6 @@ void deviceRenderWidgets()
             ImGui::PopStyleColor();
         }
 
-        if (ImGui::Button("Cancel")) {
-            siggenInput.clear();
-            ImGui::CloseCurrentPopup();
-        }
-
         if (ImGui::Button("Save")) {
             switch (siggenOption) {
             case 0:
@@ -219,6 +214,12 @@ void deviceRenderWidgets()
             ImGui::CloseCurrentPopup();
         }
 
+        ImGui::SameLine();
+        if (ImGui::Button("Cancel")) {
+            siggenInput.clear();
+            ImGui::CloseCurrentPopup();
+        }
+
         ImGui::EndPopup();
     }
 
@@ -387,12 +388,22 @@ void deviceRenderDraw()
         if (mouse.x > p0.x && mouse.x < p0.x + size.x &&
             mouse.y > p0.y && mouse.y < p0.y + size.y)
         {
-            const std::size_t si = (mouse.x - p0.x) / size.x * buffer.size();
-            const float s = buffer[si] / 4095.f * 6.6f - 3.3f;
-            char buf[12];
-            snprintf(buf, 16, "   %1.3fV", s);
+            char buf[16];
             drawList->AddLine({mouse.x, p0.y}, {mouse.x, p0.y + size.y}, IM_COL32(255, 255, 0, 255));
-            drawList->AddText(ImGui::GetMousePos(), IM_COL32(210, 210, 0, 255), buf);
+
+            {
+                const std::size_t si = (mouse.x - p0.x) / size.x * buffer.size();
+                const float s = buffer[si] / 4095.f * 6.6f - 3.3f;
+                snprintf(buf, sizeof(buf), "   %1.3fV", s);
+                drawList->AddText(mouse, IM_COL32(255, 0, 0, 255), buf);
+            }
+
+            if (drawSamplesInput) {
+                const std::size_t si = (mouse.x - p0.x) / size.x * bufferInput.size();
+                const float s = bufferInput[si] / 4095.f * 6.6f - 3.3f;
+                snprintf(buf, sizeof(buf), "   %1.3fV", s);
+                drawList->AddText({mouse.x, mouse.y + 20}, IM_COL32(0, 0, 255, 255), buf);
+            }
         }
 
         ImGui::End();
diff --git a/source/imgui/TextEditor.cpp b/source/imgui/TextEditor.cpp
index b45a21e..85bff74 100644
--- a/source/imgui/TextEditor.cpp
+++ b/source/imgui/TextEditor.cpp
@@ -46,7 +46,7 @@ TextEditor::TextEditor()
 	, mHandleKeyboardInputs(true)
 	, mHandleMouseInputs(true)
 	, mIgnoreImGuiChild(false)
-	, mShowWhitespaces(true)
+	, mShowWhitespaces(false)
 	, mStartTime(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count())
 {
 	SetPalette(GetDarkPalette());
diff --git a/source/logview.cpp b/source/logview.cpp
index 267cecb..5a771bf 100644
--- a/source/logview.cpp
+++ b/source/logview.cpp
@@ -41,7 +41,7 @@ void LogView::Draw(const char* title, bool* p_open, ImGuiWindowFlags flags)
     }
 
     ImGui::Text("Log ");
-    ImGui::SameLine();
+    ImGui::SameLine(ImGui::GetWindowWidth() - 120);
     if (ImGui::Button("Clear"))
         Clear();
     ImGui::SameLine();
diff --git a/source/main.cpp b/source/main.cpp
index 5eac338..e8641bc 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -19,37 +19,31 @@
 
 #include <chrono>
 #include <cmath>
+#include <iostream>
 #include <string>
 #include <thread>
 
-extern ImFont *fontSans;
-extern ImFont *fontMono;
-
-bool guiInitialize();
-bool guiHandleEvents();
-void guiShutdown();
-void guiRender(void (*func)());
-
-void fileRenderMenu();
-void fileRenderDialog();
-void fileInit();
-
 void codeEditorInit();
 void codeRenderMenu();
 void codeRenderToolbar();
 void codeRenderWidgets();
-
 void deviceRenderDraw();
 void deviceRenderMenu();
 void deviceRenderToolbar();
 void deviceRenderWidgets();
+void fileRenderMenu();
+void fileRenderDialog();
+void fileInit();
+bool guiInitialize();
+bool guiHandleEvents();
+void guiShutdown();
+void guiRender();
 
-static LogView logView;
+void log(const std::string& str);
 
-void log(const std::string& str)
-{
-    logView.AddLog(str);
-}
+static LogView logView;
+static ImFont *fontSans = nullptr;
+static ImFont *fontMono = nullptr;
 
 static void renderWindow();
 
@@ -58,6 +52,14 @@ int main(int, char **)
     if (!guiInitialize())
         return -1;
 
+    auto& io = ImGui::GetIO();
+    fontSans = io.Fonts->AddFontFromFileTTF("fonts/Roboto-Regular.ttf", 20);
+    fontMono = io.Fonts->AddFontFromFileTTF("fonts/RobotoMono-Regular.ttf", 20);
+    if (fontSans == nullptr || fontMono == nullptr) {
+        std::cout << "Failed to load fonts!" << std::endl;
+        return -1;
+    }
+
     codeEditorInit();
     fileInit();
 
@@ -78,6 +80,11 @@ int main(int, char **)
     return 0;
 }
 
+void log(const std::string& str)
+{
+    logView.AddLog(str);
+}
+
 void renderWindow()
 {
     // Start the new window frame and render the menu bar.
@@ -124,9 +131,6 @@ void renderWindow()
     deviceRenderDraw();
 
     // Draw everything to the screen.
-    ImGui::Render();
-    guiRender([] {
-        ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
-    });
+    guiRender();
 }
 
diff --git a/templates/1_convolve_simple.cpp b/templates/1_convolve_simple.cpp
deleted file mode 100644
index 8de05d3..0000000
--- a/templates/1_convolve_simple.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * 1_convolve_simple.cpp
- * Written by Clyne Sullivan.
- *
- * Computes a convolution in the simplest way possible. While the code is brief, it lacks many
- * possible optimizations. The convolution's result will not fill the output buffer either, as the
- * transient response is not calculated.
- */
-
-Sample *process_data(Samples samples)
-{
-    // Define our output buffer. SIZE is the largest size of the 'samples' buffer.
-    static Sample buffer[samples.size()];
-
-    // Define our filter
-    constexpr unsigned int filter_size = 3;
-	float filter[filter_size] = {
-        0.3333, 0.3333, 0.3333
-    };
-
-    // Begin convolving:
-    for (int n = 0; n < samples.size() - (filter_size - 1); n++) {
-        buffer[n] = 0;
-        for (int k = 0; k < filter_size; k++)
-            buffer[n] += samples[n + k] * filter[k];
-    }
-
-    return buffer;
-}
diff --git a/templates/2_convolve_overlap_save.cpp b/templates/2_convolve_overlap_save.cpp
deleted file mode 100644
index 57c020a..0000000
--- a/templates/2_convolve_overlap_save.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * 2_convolve_overlap_save.cpp
- * Written by Clyne Sullivan.
- *
- * This convolution examples takes an overlap-save approach, where samples from the previous run
- * are saved so that the overall operation is not interrupted (i.e. the observed output will
- * transition smoothly between processed "chunks").
- *
- * Note that there are still improvements that can be made to the code; for example, notice every
- * spot where an integer/float conversion is necessary. Operations like these may slow down the
- * computation.
- */
-
-Sample *process_data(Samples samples)
-{
-    static Sample buffer[samples.size()];
-
-    constexpr unsigned int filter_size = 3;
-	float filter[filter_size] = {
-        0.3333, 0.3333, 0.3333
-    };
-
-    // Keep a buffer of extra samples for overlap-save
-    static Sample prev[filter_size];
-
-    for (int n = 0; n < samples.size(); n++) {
-        buffer[n] = 0;
-
-        for (int k = 0; k < filter_size; k++) {
-            int i = n - (filter_size - 1) + k;
-
-            // If i is >= 0, access current sample buffer.
-            // If i is < 0, provide the previous samples from the 'prev' buffer
-            if (i >= 0)
-                buffer[n] += samples[i] * filter[k];
-            else
-                buffer[n] += prev[filter_size - 1 + i] * filter[k];
-        }
-    }
-
-    // Save samples for the next convolution run
-    for (int i = 0; i < filter_size; i++)
-        prev[i] = samples[samples.size() - filter_size + i];
-
-    return buffer;
-}
-
diff --git a/templates/3_fir.cpp b/templates/3_fir.cpp
deleted file mode 100644
index 3a68500..0000000
--- a/templates/3_fir.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * 3_fir.cpp
- * Written by Clyne Sullivan.
- *
- * The below code was written for applying FIR filters. While this is still essentially an overlap-
- * save convolution, other optimizations have been made to allow for larger filters to be applied
- * within the available execution time. Samples are also normalized so that they center around zero.
- */
-
-Sample *process_data(Samples samples)
-{
-    static Sample buffer[samples.size()];
-
-	// Define the filter:
-	constexpr unsigned int filter_size = 3;
-	static float filter[filter_size] = {
-        // Put filter values here (note: precision will be truncated for 'float' size).
-        0.3333, 0.3333, 0.3333
-	};
-
-    // Do an overlap-save convolution
-    static Sample prev[filter_size];
-
-    for (int n = 0; n < samples.size(); n++) {
-        // Using a float variable for accumulation allows for better code optimization
-        float v = 0;
-
-        for (int k = 0; k < filter_size; k++) {
-            int i = n - (filter_size - 1) + k;
-
-            auto s = i >= 0 ? samples[i] : prev[filter_size - 1 + i];
-			// Sample values are 0 to 4095. Below, the original sample is normalized to a -1.0 to
-            // 1.0 range for calculation.
-            v += (s / 2048.f - 1) * filter[k];
-        }
-
-        // Return value to sample range of 0-4095.
-        buffer[n] = (v + 1) * 2048.f;
-    }
-
-    // Save samples for next convolution
-    for (int i = 0; i < filter_size; i++)
-        prev[i] = samples[samples.size() - filter_size + i];
-
-    return buffer;
-}
-
diff --git a/templates/4_fir_pro.cpp b/templates/4_fir_pro.cpp
deleted file mode 100644
index b1a6832..0000000
--- a/templates/4_fir_pro.cpp
+++ /dev/null
@@ -1,478 +0,0 @@
-#include <cstdint>
-using float32_t = float;
-
-typedef struct
-{
-    uint16_t numTaps;     /**< number of filter coefficients in the filter. */
-    float32_t *pState;    /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
-    float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */
-} arm_fir_instance_f32;
-
-static void arm_fir_f32(const arm_fir_instance_f32 * S, float32_t * pSrc, float32_t * pDst, uint32_t blockSize);
-
-Sample *process_data(Samples samples)
-{
-	// 1. Define our array sizes (Be sure to set Run > Set buffer size... to below value!)
-	constexpr unsigned int buffer_size = 500;
-	constexpr unsigned int filter_size = 100;
-
-	// 2. Define our filter and the working arrays
-	static float filter[filter_size] = {
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,
-		.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f,.01f
-	};
-	static float input[buffer_size];
-	static float output[buffer_size];
-	static float working[buffer_size + filter_size];
-
-	// 3. Scale 0-4095 interger sample values to +/- 1.0 floats
-	for (unsigned int i = 0; i < samples.size(); i++)
-		input[i] = (samples[i] - 2048) / 2048.f;
-
-	// 4. Compute the FIR
-	arm_fir_instance_f32 fir { filter_size, working, filter };
-	arm_fir_f32(&fir, input, output, samples.size());
-
-	// 5. Convert float results back to 0-4095 range for output
-	for (unsigned int i = 0; i < samples.size(); i++)
-		samples[i] = output[i] * 2048.f + 2048;
-
-    return samples.data();
-}
-
-// Below taken from the CMSIS DSP Library (find it on GitHub)
-void arm_fir_f32(
-	const arm_fir_instance_f32 * S,
-	float32_t * pSrc,
-	float32_t * pDst,
-	uint32_t blockSize)
-{
-   float32_t *pState = S->pState;                 /* State pointer */
-   float32_t *pCoeffs = S->pCoeffs;               /* Coefficient pointer */
-   float32_t *pStateCurnt;                        /* Points to the current sample of the state */
-   float32_t *px, *pb;                            /* Temporary pointers for state and coefficient buffers */
-   float32_t acc0, acc1, acc2, acc3, acc4, acc5, acc6, acc7;     /* Accumulators */
-   float32_t x0, x1, x2, x3, x4, x5, x6, x7, c0;  /* Temporary variables to hold state and coefficient values */
-   uint32_t numTaps = S->numTaps;                 /* Number of filter coefficients in the filter */
-   uint32_t i, tapCnt, blkCnt;                    /* Loop counters */
-   float32_t p0,p1,p2,p3,p4,p5,p6,p7;             /* Temporary product values */
-
-   /* S->pState points to state array which contains previous frame (numTaps - 1) samples */
-   /* pStateCurnt points to the location where the new input data should be written */
-   pStateCurnt = &(S->pState[(numTaps - 1u)]);
-
-   /* Apply loop unrolling and compute 8 output values simultaneously.  
-    * The variables acc0 ... acc7 hold output values that are being computed:  
-    *  
-    *    acc0 =  b[numTaps-1] * x[n-numTaps-1] + b[numTaps-2] * x[n-numTaps-2] + b[numTaps-3] * x[n-numTaps-3] +...+ b[0] * x[0]  
-    *    acc1 =  b[numTaps-1] * x[n-numTaps] +   b[numTaps-2] * x[n-numTaps-1] + b[numTaps-3] * x[n-numTaps-2] +...+ b[0] * x[1]  
-    *    acc2 =  b[numTaps-1] * x[n-numTaps+1] + b[numTaps-2] * x[n-numTaps] +   b[numTaps-3] * x[n-numTaps-1] +...+ b[0] * x[2]  
-    *    acc3 =  b[numTaps-1] * x[n-numTaps+2] + b[numTaps-2] * x[n-numTaps+1] + b[numTaps-3] * x[n-numTaps]   +...+ b[0] * x[3]  
-    */
-   blkCnt = blockSize >> 3;
-
-   /* First part of the processing with loop unrolling.  Compute 8 outputs at a time.  
-   ** a second loop below computes the remaining 1 to 7 samples. */
-   while(blkCnt > 0u)
-   {
-      /* Copy four new input samples into the state buffer */
-      *pStateCurnt++ = *pSrc++;
-      *pStateCurnt++ = *pSrc++;
-      *pStateCurnt++ = *pSrc++;
-      *pStateCurnt++ = *pSrc++;
-
-      /* Set all accumulators to zero */
-      acc0 = 0.0f;
-      acc1 = 0.0f;
-      acc2 = 0.0f;
-      acc3 = 0.0f;
-      acc4 = 0.0f;
-      acc5 = 0.0f;
-      acc6 = 0.0f;
-      acc7 = 0.0f;		
-
-      /* Initialize state pointer */
-      px = pState;
-
-      /* Initialize coeff pointer */
-      pb = (pCoeffs);		
-   
-      /* This is separated from the others to avoid 
-       * a call to __aeabi_memmove which would be slower
-       */
-      *pStateCurnt++ = *pSrc++;
-      *pStateCurnt++ = *pSrc++;
-      *pStateCurnt++ = *pSrc++;
-      *pStateCurnt++ = *pSrc++;
-
-      /* Read the first seven samples from the state buffer:  x[n-numTaps], x[n-numTaps-1], x[n-numTaps-2] */
-      x0 = *px++;
-      x1 = *px++;
-      x2 = *px++;
-      x3 = *px++;
-      x4 = *px++;
-      x5 = *px++;
-      x6 = *px++;
-
-      /* Loop unrolling.  Process 8 taps at a time. */
-      tapCnt = numTaps >> 3u;
-      
-      /* Loop over the number of taps.  Unroll by a factor of 8.  
-       ** Repeat until we've computed numTaps-8 coefficients. */
-      while(tapCnt > 0u)
-      {
-         /* Read the b[numTaps-1] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-3] sample */
-         x7 = *(px++);
-
-         /* acc0 +=  b[numTaps-1] * x[n-numTaps] */
-         p0 = x0 * c0;
-
-         /* acc1 +=  b[numTaps-1] * x[n-numTaps-1] */
-         p1 = x1 * c0;
-
-         /* acc2 +=  b[numTaps-1] * x[n-numTaps-2] */
-         p2 = x2 * c0;
-
-         /* acc3 +=  b[numTaps-1] * x[n-numTaps-3] */
-         p3 = x3 * c0;
-
-         /* acc4 +=  b[numTaps-1] * x[n-numTaps-4] */
-         p4 = x4 * c0;
-
-         /* acc1 +=  b[numTaps-1] * x[n-numTaps-5] */
-         p5 = x5 * c0;
-
-         /* acc2 +=  b[numTaps-1] * x[n-numTaps-6] */
-         p6 = x6 * c0;
-
-         /* acc3 +=  b[numTaps-1] * x[n-numTaps-7] */
-         p7 = x7 * c0;
-         
-         /* Read the b[numTaps-2] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-4] sample */
-         x0 = *(px++);
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-
-         /* Perform the multiply-accumulate */
-         p0 = x1 * c0;
-         p1 = x2 * c0;   
-         p2 = x3 * c0;   
-         p3 = x4 * c0;   
-         p4 = x5 * c0;   
-         p5 = x6 * c0;   
-         p6 = x7 * c0;   
-         p7 = x0 * c0;   
-         
-         /* Read the b[numTaps-3] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-5] sample */
-         x1 = *(px++);
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-         /* Perform the multiply-accumulates */      
-         p0 = x2 * c0;
-         p1 = x3 * c0;   
-         p2 = x4 * c0;   
-         p3 = x5 * c0;   
-         p4 = x6 * c0;   
-         p5 = x7 * c0;   
-         p6 = x0 * c0;   
-         p7 = x1 * c0;   
-
-         /* Read the b[numTaps-4] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-6] sample */
-         x2 = *(px++);
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-         /* Perform the multiply-accumulates */      
-         p0 = x3 * c0;
-         p1 = x4 * c0;   
-         p2 = x5 * c0;   
-         p3 = x6 * c0;   
-         p4 = x7 * c0;   
-         p5 = x0 * c0;   
-         p6 = x1 * c0;   
-         p7 = x2 * c0;   
-
-         /* Read the b[numTaps-4] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-6] sample */
-         x3 = *(px++);
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-         /* Perform the multiply-accumulates */      
-         p0 = x4 * c0;
-         p1 = x5 * c0;   
-         p2 = x6 * c0;   
-         p3 = x7 * c0;   
-         p4 = x0 * c0;   
-         p5 = x1 * c0;   
-         p6 = x2 * c0;   
-         p7 = x3 * c0;   
-
-         /* Read the b[numTaps-4] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-6] sample */
-         x4 = *(px++);
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-         /* Perform the multiply-accumulates */      
-         p0 = x5 * c0;
-         p1 = x6 * c0;   
-         p2 = x7 * c0;   
-         p3 = x0 * c0;   
-         p4 = x1 * c0;   
-         p5 = x2 * c0;   
-         p6 = x3 * c0;   
-         p7 = x4 * c0;   
-
-         /* Read the b[numTaps-4] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-6] sample */
-         x5 = *(px++);
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-         /* Perform the multiply-accumulates */      
-         p0 = x6 * c0;
-         p1 = x7 * c0;   
-         p2 = x0 * c0;   
-         p3 = x1 * c0;   
-         p4 = x2 * c0;   
-         p5 = x3 * c0;   
-         p6 = x4 * c0;   
-         p7 = x5 * c0;   
-
-         /* Read the b[numTaps-4] coefficient */
-         c0 = *(pb++);
-
-         /* Read x[n-numTaps-6] sample */
-         x6 = *(px++);
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-         /* Perform the multiply-accumulates */      
-         p0 = x7 * c0;
-         p1 = x0 * c0;   
-         p2 = x1 * c0;   
-         p3 = x2 * c0;   
-         p4 = x3 * c0;   
-         p5 = x4 * c0;   
-         p6 = x5 * c0;   
-         p7 = x6 * c0;   
-
-         tapCnt--;
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-      }
-
-      /* If the filter length is not a multiple of 8, compute the remaining filter taps */
-      tapCnt = numTaps % 0x8u;
-
-      while(tapCnt > 0u)
-      {
-         /* Read coefficients */
-         c0 = *(pb++);
-
-         /* Fetch 1 state variable */
-         x7 = *(px++);
-
-         /* Perform the multiply-accumulates */      
-         p0 = x0 * c0;
-         p1 = x1 * c0;   
-         p2 = x2 * c0;   
-         p3 = x3 * c0;   
-         p4 = x4 * c0;   
-         p5 = x5 * c0;   
-         p6 = x6 * c0;   
-         p7 = x7 * c0;   
-
-         /* Reuse the present sample states for next sample */
-         x0 = x1;
-         x1 = x2;
-         x2 = x3;
-         x3 = x4;
-         x4 = x5;
-         x5 = x6;
-         x6 = x7;
-         
-         acc0 += p0;
-         acc1 += p1;
-         acc2 += p2;
-         acc3 += p3;
-         acc4 += p4;
-         acc5 += p5;
-         acc6 += p6;
-         acc7 += p7;
-
-         /* Decrement the loop counter */
-         tapCnt--;
-      }
-
-      /* Advance the state pointer by 8 to process the next group of 8 samples */
-      pState = pState + 8;
-
-      /* The results in the 8 accumulators, store in the destination buffer. */
-      *pDst++ = acc0;
-      *pDst++ = acc1;
-      *pDst++ = acc2;
-      *pDst++ = acc3;
-      *pDst++ = acc4;
-      *pDst++ = acc5;
-      *pDst++ = acc6;
-      *pDst++ = acc7;
-
-      blkCnt--;
-   }
-
-   /* If the blockSize is not a multiple of 8, compute any remaining output samples here.  
-   ** No loop unrolling is used. */
-   blkCnt = blockSize % 0x8u;
-
-   while(blkCnt > 0u)
-   {
-      /* Copy one sample at a time into state buffer */
-      *pStateCurnt++ = *pSrc++;
-
-      /* Set the accumulator to zero */
-      acc0 = 0.0f;
-
-      /* Initialize state pointer */
-      px = pState;
-
-      /* Initialize Coefficient pointer */
-      pb = (pCoeffs);
-
-      i = numTaps;
-
-      /* Perform the multiply-accumulates */
-      do
-      {
-         acc0 += *px++ * *pb++;
-         i--;
-
-      } while(i > 0u);
-
-      /* The result is store in the destination buffer. */
-      *pDst++ = acc0;
-
-      /* Advance state pointer by 1 for the next sample */
-      pState = pState + 1;
-
-      blkCnt--;
-   }
-
-   /* Processing is complete.  
-   ** Now copy the last numTaps - 1 samples to the start of the state buffer.  
-   ** This prepares the state buffer for the next function call. */
-
-   /* Points to the start of the state buffer */
-   pStateCurnt = S->pState;
-
-   tapCnt = (numTaps - 1u) >> 2u;
-
-   /* copy data */
-   while(tapCnt > 0u)
-   {
-      *pStateCurnt++ = *pState++;
-      *pStateCurnt++ = *pState++;
-      *pStateCurnt++ = *pState++;
-      *pStateCurnt++ = *pState++;
-
-      /* Decrement the loop counter */
-      tapCnt--;
-   }
-
-   /* Calculate remaining number of copies */
-   tapCnt = (numTaps - 1u) % 0x4u;
-
-   /* Copy the remaining q31_t data */
-   while(tapCnt > 0u)
-   {
-      *pStateCurnt++ = *pState++;
-
-      /* Decrement the loop counter */
-      tapCnt--;
-   }
-}
diff --git a/templates/5_fir_differentiator.cpp b/templates/5_fir_differentiator.cpp
deleted file mode 100644
index 72415c6..0000000
--- a/templates/5_fir_differentiator.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * 5_fir_differentiator.cpp
- * Written by Clyne Sullivan.
- *
- * Does an FIR differentiation on the incoming signal, so that the output is representative of the
- * rate of change of the input.
- * A scaling factor is applied so that the output's form is more clearly visible.
- */
-
-Sample *process_data(Samples samples)
-{
-    constexpr int scaling_factor = 4;
-	static Sample output[samples.size()];
-    static Sample prev = 2048;
-
-    // Compute the first output value using the saved sample.
-    output[0] = 2048 + ((samples[0] - prev) * scaling_factor);
-
-	for (unsigned int i = 1; i < samples.size(); i++) {
-        // Take the rate of change and scale it.
-        // 2048 is added as the output should be centered in the voltage range.
-		output[i] = 2048 + ((samples[i] - samples[i - 1]) * scaling_factor);
-    }
-
-	// Save the last sample for the next iteration.
-    prev = samples[samples.size() - 1];
-
-    return output;
-}
-
diff --git a/templates/6_iir_test.cpp b/templates/6_iir_test.cpp
deleted file mode 100644
index 116a680..0000000
--- a/templates/6_iir_test.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-Sample *process_data(Samples samples)
-{
-	constexpr float alpha = 0.7;
-
-	static Sample prev = 2048;
-
-	samples[0] = (1 - alpha) * samples[0] + alpha * prev;
-	for (unsigned int i = 1; i < samples.size(); i++)
-		samples[i] = (1 - alpha) * samples[i] + alpha * samples[i - 1];
-	prev = samples[samples.size() - 1];
-
-	return samples.data();
-}
diff --git a/templates/7_iir_echo.cpp b/templates/7_iir_echo.cpp
deleted file mode 100644
index 57e5605..0000000
--- a/templates/7_iir_echo.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-Sample *process_data(Samples samples)
-{
-	constexpr float alpha = 0.75;
-	constexpr unsigned int D = 100;
-
-	static Sample output[samples.size()];
-	static Sample prev[D]; // prev[0] = output[0 - D]
-
-	// Do calculations with previous output
-	for (unsigned int i = 0; i < D; i++)
-		output[i] = samples[i] + alpha * (prev[i] - 2048);
-
-	// Do calculations with current samples
-	for (unsigned int i = D; i < samples.size(); i++)
-		output[i] = samples[i] + alpha * (output[i - D] - 2048);
-
-	// Save outputs for next computation
-	for (unsigned int i = 0; i < D; i++)
-		prev[i] = output[samples.size() - (D - i)];
-
-	return output;
-}
-- 
cgit v1.2.3


From 67ffe1f2ce9f3432cb524dced5e6fba96519b4fd Mon Sep 17 00:00:00 2001
From: Clyne Sullivan <clyne@bitgloo.com>
Date: Mon, 16 May 2022 17:03:15 -0400
Subject: building with mingw

---
 Makefile        | 26 ++++++++++++++++----------
 source/file.cpp |  2 +-
 source/main.cpp |  2 +-
 3 files changed, 18 insertions(+), 12 deletions(-)

(limited to 'source/file.cpp')

diff --git a/Makefile b/Makefile
index 81e580d..fdf87d6 100644
--- a/Makefile
+++ b/Makefile
@@ -1,26 +1,32 @@
+#linux: CXXFILES += source/serial/src/impl/unix.cc source/serial/src/impl/list_ports/list_ports_unix.cc
+#linux: LDFLAGS = -lSDL2 -lGL -lpthread
+
+CROSS = x86_64-w64-mingw32-
+CXX = $(CROSS)g++
+
 CXXFILES := \
     source/serial/src/serial.cc \
-    source/serial/src/impl/unix.cc \
-    source/serial/src/impl/list_ports/list_ports_linux.cc \
+    source/serial/src/impl/win.cc \
+    source/serial/src/impl/list_ports/list_ports_win.cc \
     $(wildcard source/imgui/backends/*.cpp) \
     $(wildcard source/imgui/*.cpp) \
     $(wildcard source/stmdsp/*.cpp) \
     $(wildcard source/*.cpp)
 
 OFILES := $(patsubst %.cc, %.o, $(patsubst %.cpp, %.o, $(CXXFILES)))
-OUTPUT := stmdspgui
+OUTPUT := stmdspgui.exe
 
-#CXXFLAGS := -std=c++20 -O2 \
-#            -Isource -Isource/imgui -Isource/stmdsp -Isource/serial/include
-CXXFLAGS := -std=c++20 -ggdb -O0 -g3 \
+CXXFLAGS := -std=c++20 -O2 \
             -Isource -Isource/imgui -Isource/stmdsp -Isource/serial/include \
-            -Wall -Wextra -pedantic
+            -Wall -Wextra -pedantic \
+            -DSTMDSP_WIN32 -Wa,-mbig-obj
+LDFLAGS = -mwindows -lSDL2 -lopengl32 -lsetupapi -lole32
 
 all: $(OUTPUT)
 
 $(OUTPUT): $(OFILES)
 	@echo "  LD    " $(OUTPUT)
-	@g++ $(OFILES) -o $(OUTPUT) -lSDL2 -lGL -lpthread
+	@$(CXX) $(OFILES) -o $(OUTPUT) $(LDFLAGS)
 
 clean:
 	@echo "  CLEAN"
@@ -28,9 +34,9 @@ clean:
 
 %.o: %.cpp
 	@echo "  CXX   " $<
-	@g++ $(CXXFLAGS) -c $< -o $@
+	@$(CXX) $(CXXFLAGS) -c $< -o $@
 
 %.o: %.cc
 	@echo "  CXX   " $<
-	@g++ $(CXXFLAGS) -c $< -o $@
+	@$(CXX) $(CXXFLAGS) -c $< -o $@
 
diff --git a/source/file.cpp b/source/file.cpp
index fe5dafb..b4332f4 100644
--- a/source/file.cpp
+++ b/source/file.cpp
@@ -104,7 +104,7 @@ void fileRenderMenu()
 
         if (ImGui::BeginMenu("Open Example")) {
             for (const auto& file : fileExampleList) {
-                if (ImGui::MenuItem(file.filename().c_str())) {
+                if (ImGui::MenuItem(file.filename().string().c_str())) {
                     fileCurrentPath = file.string();
                     openCurrentFile();
 
diff --git a/source/main.cpp b/source/main.cpp
index e8641bc..d6277b7 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -47,7 +47,7 @@ static ImFont *fontMono = nullptr;
 
 static void renderWindow();
 
-int main(int, char **)
+int main(int argc, char *argv[])
 {
     if (!guiInitialize())
         return -1;
-- 
cgit v1.2.3