Cleanup

src/vamp_zero/app.cpp

@@ -10,6 +10,7 @@
 #include <future>
 #include <iostream>
 #include <iterator>
+#include <memory>
 #include <string>
 #include <string_view>
 #include <thread>
@@ -27,6 +28,7 @@
 #include <modulus.hpp>
 
 #include <vamp_zero/config.hpp>
+#include <vamp_zero/audio.hpp>
 #include <vamp_zero/database.hpp>
 #include <vamp_zero/errors.hpp>
 #include <vamp_zero/library.hpp>
@@ -129,6 +131,14 @@ auto load_initial_state(vamp_zero::config const& config) -> std::expected<vamp_z
   auto state = vamp_zero::app_state{
     .performance = std::move(*performance),
     .practice = std::move(*practice),
+    .audio = {
+      .track_enabled = config.audio.track_enabled,
+      .metronome_enabled = config.audio.metronome_enabled,
+      .metronome_bpm = config.audio.metronome_bpm,
+      .metronome_min_bpm = config.audio.metronome_min_bpm,
+      .metronome_max_bpm = config.audio.metronome_max_bpm,
+      .metronome_step = config.audio.metronome_step,
+    },
   };
   if (auto valid = vamp_zero::validate_app_state(state); !valid) {
     return std::unexpected(valid.error());
@@ -136,7 +146,7 @@ auto load_initial_state(vamp_zero::config const& config) -> std::expected<vamp_z
   return state;
 }
 
-auto run_headless(vamp_zero::config const& config, vamp_zero::control_state& state) -> std::expected<void, modulus::error> {
+auto run_headless(vamp_zero::config const& config, vamp_zero::control_state& state, vamp_zero::audio_controller* audio) -> std::expected<void, modulus::error> {
   auto io = boost::asio::io_context{};
   auto endpoint = make_server_endpoint(config);
   if (!endpoint) {
@@ -147,6 +157,12 @@ auto run_headless(vamp_zero::config const& config, vamp_zero::control_state& sta
   if (!started) {
     return std::unexpected(started.error());
   }
+  if (audio != nullptr) {
+    state.set_observer([audio](vamp_zero::app_state app) {
+      audio->sync(app);
+    });
+    audio->sync(state.snapshot());
+  }
   auto heartbeat = write_heartbeat(config);
   if (!heartbeat) {
     server.stop();
@@ -162,7 +178,7 @@ auto run_headless(vamp_zero::config const& config, vamp_zero::control_state& sta
   return {};
 }
 
-auto run_display(vamp_zero::config const& config, vamp_zero::control_state& state) -> std::expected<void, modulus::error> {
+auto run_display(vamp_zero::config const& config, vamp_zero::control_state& state, vamp_zero::audio_controller* audio) -> std::expected<void, modulus::error> {
   auto io = boost::asio::io_context{};
   auto endpoint = make_server_endpoint(config);
   if (!endpoint) {
@@ -171,12 +187,18 @@ auto run_display(vamp_zero::config const& config, vamp_zero::control_state& stat
   auto ui = vamp_zero::zero_ui{io.get_executor(), config.display, [&state](vamp_protocol::page_command command) {
     static_cast<void>(state.apply(command));
   }};
-  state.set_observer([&ui, &config](vamp_zero::app_state app) {
+  state.set_observer([&ui, &config, audio](vamp_zero::app_state app) {
+    if (audio != nullptr) {
+      audio->sync(app);
+    }
     auto status = ui.publish(vamp_zero::make_ui_state(config, std::move(app)));
     if (!status) {
       modulus::log_error("failed to publish UI state: " + status.error().describe());
     }
   });
+  if (audio != nullptr) {
+    audio->sync(state.snapshot());
+  }
   auto published = ui.publish(vamp_zero::make_ui_state(config, state.snapshot()));
   if (!published) {
     return std::unexpected(published.error());
@@ -316,8 +338,15 @@ auto vamp_zero::run(vamp_zero::command_line command) -> std::expected<void, modu
     return std::unexpected(initial.error());
   }
   auto state = vamp_zero::control_state{*config, std::move(*initial)};
-  if (config->runtime.headless) {
-    return run_headless(*config, state);
+  auto audio_controller = std::unique_ptr<vamp_zero::audio_controller>{};
+  auto audio = vamp_zero::create_audio_controller(config->audio);
+  if (!audio) {
+    modulus::log_error("audio unavailable: " + audio.error().describe());
+  } else {
+    audio_controller = std::move(*audio);
   }
-  return run_display(*config, state);
+  if (config->runtime.headless) {
+    return run_headless(*config, state, audio_controller.get());
+  }
+  return run_display(*config, state, audio_controller.get());
 }

src/vamp_zero/audio.cpp

@@ -0,0 +1,108 @@
+#include <vamp_zero/audio.hpp>
+
+#include <expected>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <utility>
+
+#include <modulus.hpp>
+#include <sonus.hpp>
+
+#include <vamp_zero/navigation.hpp>
+
+namespace {
+
+auto score_active(vamp_zero::app_state const& state) -> std::bool_t {
+  if (state.mode == vamp_zero::app_mode::PERFORMANCE_SCORE) {
+    return vamp_zero::active_part(state) != nullptr;
+  }
+  if (state.mode == vamp_zero::app_mode::PRACTICE_SCORE) {
+    auto const* exercise = vamp_zero::active_practice(state);
+    return exercise != nullptr && vamp_zero::selected_practice_variant(state, *exercise) != nullptr;
+  }
+  return false;
+}
+
+auto log_audio_error(std::string const& action, modulus::error const& error) -> void {
+  modulus::log_error(action + ": " + error.describe());
+}
+
+}
+
+vamp_zero::audio_controller::audio_controller(vamp_zero::audio_config config, sonus::engine engine)
+  : config_{config}, engine_{std::move(engine)} {}
+
+vamp_zero::audio_controller::~audio_controller() {
+  auto lock = std::scoped_lock{mutex_};
+  engine_.stop_metronome();
+  engine_.stop_all();
+  engine_.stop();
+}
+
+auto vamp_zero::audio_controller::make_metronome_config(vamp_zero::app_state const& state) const -> sonus::metronome_config {
+  auto result = sonus::metronome_config{};
+  result.bpm = state.audio.metronome_bpm;
+  result.beats_per_bar = config_.beats_per_bar;
+  result.volume = config_.metronome_volume;
+  return result;
+}
+
+auto vamp_zero::audio_controller::sync(vamp_zero::app_state const& state) -> void {
+  auto lock = std::scoped_lock{mutex_};
+  auto const should_run_metronome = state.audio.metronome_enabled && score_active(state);
+  if (!should_run_metronome) {
+    if (metronome_running_) {
+      engine_.stop_metronome();
+      metronome_running_ = false;
+    }
+    return;
+  }
+
+  auto metronome = make_metronome_config(state);
+  if (!metronome_running_) {
+    auto started = engine_.start_metronome(metronome);
+    if (!started) {
+      log_audio_error("failed to start metronome", started.error());
+      engine_.stop_metronome();
+      metronome_running_ = false;
+      return;
+    }
+    metronome_running_ = true;
+    last_metronome_bpm_ = metronome.bpm;
+    return;
+  }
+
+  if (last_metronome_bpm_ != metronome.bpm) {
+    auto updated = engine_.update_metronome(metronome);
+    if (!updated) {
+      log_audio_error("failed to update metronome", updated.error());
+      engine_.stop_metronome();
+      metronome_running_ = false;
+      return;
+    }
+    last_metronome_bpm_ = metronome.bpm;
+  }
+}
+
+auto vamp_zero::create_audio_controller(vamp_zero::audio_config const& config) -> std::expected<std::unique_ptr<vamp_zero::audio_controller>, modulus::error> {
+  if (!config.enabled) {
+    return nullptr;
+  }
+
+  auto sonus_config = sonus::audio_config{};
+  sonus_config.sample_rate = 48000;
+  sonus_config.channels = 2;
+  sonus_config.master_volume = config.master_volume;
+
+  auto engine = sonus::engine::create(sonus_config);
+  if (!engine) {
+    return std::unexpected(engine.error());
+  }
+  auto started = engine->start();
+  if (!started) {
+    return std::unexpected(started.error());
+  }
+
+  return std::make_unique<vamp_zero::audio_controller>(config, std::move(*engine));
+}

src/vamp_zero/config.cpp

@@ -1,5 +1,6 @@
 #include <vamp_zero/config.hpp>
 
+#include <cmath>
 #include <cstdint>
 #include <expected>
 #include <fstream>
@@ -68,6 +69,50 @@ auto optional_bool(boost::json::object const& object, std::string_view field, st
   return found->value().as_bool();
 }
 
+auto optional_uint32(boost::json::object const& object, std::string_view field, std::uint32_t fallback, std::uint32_t min_value, std::uint32_t max_value) -> std::expected<std::uint32_t, modulus::error> {
+  auto found = object.find(field);
+  if (found == object.end()) {
+    return fallback;
+  }
+  auto value = std::uint64_t{};
+  if (found->value().is_uint64()) {
+    value = found->value().as_uint64();
+  } else if (found->value().is_int64()) {
+    auto signed_value = found->value().as_int64();
+    if (signed_value < 0) {
+      return std::unexpected(invalid(std::string{field} + " must not be negative"));
+    }
+    value = static_cast<std::uint64_t>(signed_value);
+  } else {
+    return std::unexpected(invalid(std::string{field} + " must be an integer"));
+  }
+  if (value < min_value || value > max_value) {
+    return std::unexpected(invalid(std::string{field} + " is out of range"));
+  }
+  return static_cast<std::uint32_t>(value);
+}
+
+auto optional_float(boost::json::object const& object, std::string_view field, std::float32_t fallback, std::float32_t min_value, std::float32_t max_value) -> std::expected<std::float32_t, modulus::error> {
+  auto found = object.find(field);
+  if (found == object.end()) {
+    return fallback;
+  }
+  auto value = std::float64_t{};
+  if (found->value().is_double()) {
+    value = found->value().as_double();
+  } else if (found->value().is_uint64()) {
+    value = static_cast<std::float64_t>(found->value().as_uint64());
+  } else if (found->value().is_int64()) {
+    value = static_cast<std::float64_t>(found->value().as_int64());
+  } else {
+    return std::unexpected(invalid(std::string{field} + " must be a number"));
+  }
+  if (!std::isfinite(value) || value < min_value || value > max_value) {
+    return std::unexpected(invalid(std::string{field} + " is out of range"));
+  }
+  return static_cast<std::float32_t>(value);
+}
+
 auto parse_hardware(std::string const& value) -> std::expected<vamp_zero::hardware_mode, modulus::error> {
   if (value == "fake") {
     return vamp_zero::hardware_mode::FAKE;
@@ -162,6 +207,55 @@ auto parse_control(boost::json::object const& root, vamp_zero::control_config fa
   return result;
 }
 
+auto parse_audio(boost::json::object const& root, vamp_zero::audio_config fallback) -> std::expected<vamp_zero::audio_config, modulus::error> {
+  auto object = optional_object(root, "audio");
+  if (!object) {
+    return std::unexpected(object.error());
+  }
+  if (*object == nullptr) {
+    return fallback;
+  }
+  auto enabled = optional_bool(**object, "enabled", fallback.enabled);
+  auto track_enabled = optional_bool(**object, "track_enabled", fallback.track_enabled);
+  auto metronome_enabled = optional_bool(**object, "metronome_enabled", fallback.metronome_enabled);
+  auto metronome_bpm = optional_uint32(**object, "metronome_bpm", fallback.metronome_bpm, 1U, 400U);
+  auto metronome_min_bpm = optional_uint32(**object, "metronome_min_bpm", fallback.metronome_min_bpm, 1U, 400U);
+  auto metronome_max_bpm = optional_uint32(**object, "metronome_max_bpm", fallback.metronome_max_bpm, 1U, 400U);
+  auto metronome_step = optional_uint32(**object, "metronome_step", fallback.metronome_step, 1U, 100U);
+  auto beats_per_bar = optional_uint32(**object, "beats_per_bar", fallback.beats_per_bar, 1U, 16U);
+  auto master_volume = optional_float(**object, "master_volume", fallback.master_volume, 0.0F, 1.0F);
+  auto metronome_volume = optional_float(**object, "metronome_volume", fallback.metronome_volume, 0.0F, 1.0F);
+  if (!enabled || !track_enabled || !metronome_enabled || !metronome_bpm || !metronome_min_bpm || !metronome_max_bpm || !metronome_step || !beats_per_bar || !master_volume || !metronome_volume) {
+    return std::unexpected(!enabled ? enabled.error()
+      : (!track_enabled ? track_enabled.error()
+      : (!metronome_enabled ? metronome_enabled.error()
+      : (!metronome_bpm ? metronome_bpm.error()
+      : (!metronome_min_bpm ? metronome_min_bpm.error()
+      : (!metronome_max_bpm ? metronome_max_bpm.error()
+      : (!metronome_step ? metronome_step.error()
+      : (!beats_per_bar ? beats_per_bar.error()
+      : (!master_volume ? master_volume.error() : metronome_volume.error())))))))));
+  }
+  if (*metronome_min_bpm > *metronome_max_bpm) {
+    return std::unexpected(invalid("audio.metronome_min_bpm must be less than or equal to audio.metronome_max_bpm"));
+  }
+  if (*metronome_bpm < *metronome_min_bpm || *metronome_bpm > *metronome_max_bpm) {
+    return std::unexpected(invalid("audio.metronome_bpm must be within the configured metronome range"));
+  }
+  return vamp_zero::audio_config{
+    .enabled = *enabled,
+    .track_enabled = *track_enabled,
+    .metronome_enabled = *metronome_enabled,
+    .metronome_bpm = *metronome_bpm,
+    .metronome_min_bpm = *metronome_min_bpm,
+    .metronome_max_bpm = *metronome_max_bpm,
+    .metronome_step = *metronome_step,
+    .beats_per_bar = *beats_per_bar,
+    .master_volume = *master_volume,
+    .metronome_volume = *metronome_volume,
+  };
+}
+
 }
 
 auto vamp_zero::parse_config(boost::json::value const& value) -> std::expected<vamp_zero::config, modulus::error> {
@@ -180,12 +274,14 @@ auto vamp_zero::parse_config(boost::json::value const& value) -> std::expected<v
   auto runtime = parse_runtime(**root, result.runtime);
   auto database = parse_database(**root, result.database);
   auto control = parse_control(**root, result.control);
-  if (!runtime || !database || !control) {
-    return std::unexpected(!runtime ? runtime.error() : (!database ? database.error() : control.error()));
+  auto audio = parse_audio(**root, result.audio);
+  if (!runtime || !database || !control || !audio) {
+    return std::unexpected(!runtime ? runtime.error() : (!database ? database.error() : (!control ? control.error() : audio.error())));
   }
   result.runtime = std::move(*runtime);
   result.database = std::move(*database);
   result.control = std::move(*control);
+  result.audio = std::move(*audio);
   if (auto found = (*root)->find("display"); found != (*root)->end()) {
     auto display = luma::parse_application_config(found->value());
     if (!display) {

src/vamp_zero/page_control.cpp

@@ -18,7 +18,12 @@
 
 namespace {
 
-constexpr auto main_menu_count = std::size_t{2};
+constexpr auto main_menu_performance = std::size_t{0};
+constexpr auto main_menu_practice = std::size_t{1};
+constexpr auto main_menu_track = std::size_t{2};
+constexpr auto main_menu_metronome = std::size_t{3};
+constexpr auto main_menu_tempo = std::size_t{4};
+constexpr auto main_menu_count = std::size_t{5};
 
 auto wrap_next(std::size_t value, std::size_t count) -> std::size_t {
   if (count == 0U) {
@@ -38,7 +43,28 @@ auto menu_row_count(std::size_t item_count) -> std::size_t {
   return item_count + 1U;
 }
 
+auto clamp_audio_state(vamp_zero::audio_state audio) -> vamp_zero::audio_state {
+  audio.metronome_min_bpm = std::clamp<std::uint32_t>(audio.metronome_min_bpm, 1U, 400U);
+  audio.metronome_max_bpm = std::clamp<std::uint32_t>(audio.metronome_max_bpm, audio.metronome_min_bpm, 400U);
+  audio.metronome_step = std::clamp<std::uint32_t>(audio.metronome_step, 1U, 100U);
+  audio.metronome_bpm = std::clamp(audio.metronome_bpm, audio.metronome_min_bpm, audio.metronome_max_bpm);
+  return audio;
+}
+
+auto increase_bpm(vamp_zero::audio_state& audio) -> void {
+  audio.metronome_bpm = audio.metronome_bpm > audio.metronome_max_bpm - std::min(audio.metronome_step, audio.metronome_max_bpm)
+    ? audio.metronome_max_bpm
+    : audio.metronome_bpm + audio.metronome_step;
+}
+
+auto decrease_bpm(vamp_zero::audio_state& audio) -> void {
+  audio.metronome_bpm = audio.metronome_bpm < audio.metronome_min_bpm + audio.metronome_step
+    ? audio.metronome_min_bpm
+    : audio.metronome_bpm - audio.metronome_step;
+}
+
 auto clamp_state(vamp_zero::app_state state) -> vamp_zero::app_state {
+  state.audio = clamp_audio_state(state.audio);
   state.selected_main_menu_index = std::min(state.selected_main_menu_index, main_menu_count - 1U);
   state.selected_song_index = std::min(state.selected_song_index, menu_row_count(state.performance.groups.size()) - 1U);
   if (auto const* group = selected_group(state); group != nullptr) {
@@ -96,6 +122,10 @@ auto clamp_state(vamp_zero::app_state state) -> vamp_zero::app_state {
     }
   }
 
+  if (state.mode != vamp_zero::app_mode::MAIN_MENU) {
+    state.audio.tempo_editing = false;
+  }
+
   if (auto pages = active_pages(state); pages != 0U) {
     state.page_index = std::min(state.page_index, pages - 1U);
   } else if (state.mode != vamp_zero::app_mode::PERFORMANCE_SCORE && state.mode != vamp_zero::app_mode::PRACTICE_SCORE) {
@@ -114,6 +144,18 @@ auto command_json(vamp_zero::app_state const& state) -> boost::json::object {
   return commands;
 }
 
+auto audio_json(vamp_zero::app_state const& state) -> boost::json::object {
+  auto audio = boost::json::object{};
+  audio["track_enabled"] = state.audio.track_enabled;
+  audio["metronome_enabled"] = state.audio.metronome_enabled;
+  audio["metronome_bpm"] = static_cast<std::uint64_t>(state.audio.metronome_bpm);
+  audio["metronome_min_bpm"] = static_cast<std::uint64_t>(state.audio.metronome_min_bpm);
+  audio["metronome_max_bpm"] = static_cast<std::uint64_t>(state.audio.metronome_max_bpm);
+  audio["metronome_step"] = static_cast<std::uint64_t>(state.audio.metronome_step);
+  audio["tempo_editing"] = state.audio.tempo_editing;
+  return audio;
+}
+
 auto part_json(vamp_zero::library_part const& part) -> boost::json::object {
   auto result = boost::json::object{};
   result["id"] = part.id;
@@ -291,17 +333,25 @@ auto vamp_zero::apply_app_command(vamp_zero::app_state state, vamp_protocol::pag
 
   switch (state.mode) {
   case vamp_zero::app_mode::MAIN_MENU:
-    if (command == vamp_protocol::page_command::NEXT) {
+    if (state.audio.tempo_editing) {
+      if (command == vamp_protocol::page_command::NEXT) {
+        increase_bpm(state.audio);
+      } else if (command == vamp_protocol::page_command::PREVIOUS) {
+        decrease_bpm(state.audio);
+      } else {
+        state.audio.tempo_editing = false;
+      }
+    } else if (command == vamp_protocol::page_command::NEXT) {
       state.selected_main_menu_index = wrap_next(state.selected_main_menu_index, main_menu_count);
     } else if (command == vamp_protocol::page_command::PREVIOUS) {
       state.selected_main_menu_index = wrap_previous(state.selected_main_menu_index, main_menu_count);
-    } else if (state.selected_main_menu_index == 0U) {
+    } else if (state.selected_main_menu_index == main_menu_performance) {
       state.mode = vamp_zero::app_mode::PERFORMANCE_SONG_MENU;
       state.selected_song_index = 0;
       state.selected_part_index = 0;
       state.active_part_id.clear();
       state.page_index = 0;
-    } else {
+    } else if (state.selected_main_menu_index == main_menu_practice) {
       state.mode = vamp_zero::app_mode::PRACTICE_TYPE_MENU;
       state.selected_practice_type_index = 0;
       state.selected_practice_lesson_index = 0;
@@ -309,6 +359,12 @@ auto vamp_zero::apply_app_command(vamp_zero::app_state state, vamp_protocol::pag
       state.selected_practice_key_index = 0;
       state.active_practice_id.clear();
       state.page_index = 0;
+    } else if (state.selected_main_menu_index == main_menu_track) {
+      state.audio.track_enabled = !state.audio.track_enabled;
+    } else if (state.selected_main_menu_index == main_menu_metronome) {
+      state.audio.metronome_enabled = !state.audio.metronome_enabled;
+    } else if (state.selected_main_menu_index == main_menu_tempo) {
+      state.audio.tempo_editing = true;
     }
     return clamp_state(std::move(state));
 
@@ -523,6 +579,7 @@ auto vamp_zero::app_status_json(vamp_zero::app_state const& state) -> boost::jso
   root["practice"] = practice_json(state);
   root["selection"] = std::move(selection);
   root["active"] = std::move(active);
+  root["audio"] = audio_json(state);
   root["commands"] = command_json(state);
   root["remote"] = std::move(remote);
   return root;
@@ -567,6 +624,21 @@ auto vamp_zero::validate_app_state(vamp_zero::app_state const& state) -> std::ex
   if (state.selected_main_menu_index >= main_menu_count) {
     return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "selected main menu index is out of range"));
   }
+  if (state.audio.metronome_min_bpm == 0U || state.audio.metronome_min_bpm > 400U) {
+    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "metronome minimum BPM is out of range"));
+  }
+  if (state.audio.metronome_max_bpm < state.audio.metronome_min_bpm || state.audio.metronome_max_bpm > 400U) {
+    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "metronome maximum BPM is out of range"));
+  }
+  if (state.audio.metronome_step == 0U || state.audio.metronome_step > 100U) {
+    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "metronome BPM step is out of range"));
+  }
+  if (state.audio.metronome_bpm < state.audio.metronome_min_bpm || state.audio.metronome_bpm > state.audio.metronome_max_bpm) {
+    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "metronome BPM is out of range"));
+  }
+  if (state.audio.tempo_editing && state.mode != vamp_zero::app_mode::MAIN_MENU) {
+    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "tempo edit mode requires the main menu"));
+  }
   if (state.selected_song_index >= menu_row_count(state.performance.groups.size())) {
     return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::INVALID_ARGUMENT, "selected performance song row is out of range"));
   }

src/vamp_zero/ui.cpp

@@ -150,6 +150,13 @@ auto draw_main_menu(luma::draw_context& context, luma::rect bounds, vamp_zero::a
   auto row_width = bounds.width - 72.0F;
   draw_row(context, {.x = bounds.x + 36.0F, .y = list_y, .width = row_width, .height = row_height}, "Performance Mode", std::to_string(state.performance.groups.size()) + " SONGS", state.selected_main_menu_index == 0U);
   draw_row(context, {.x = bounds.x + 36.0F, .y = list_y + row_height, .width = row_width, .height = row_height}, "Practice Mode", std::to_string(state.practice.exercises.size()) + " EXERCISES", state.selected_main_menu_index == 1U);
+  draw_row(context, {.x = bounds.x + 36.0F, .y = list_y + row_height * 2.0F, .width = row_width, .height = row_height}, "Track", state.audio.track_enabled ? "ON" : "OFF", state.selected_main_menu_index == 2U);
+  draw_row(context, {.x = bounds.x + 36.0F, .y = list_y + row_height * 3.0F, .width = row_width, .height = row_height}, "Metronome", state.audio.metronome_enabled ? "ON" : "OFF", state.selected_main_menu_index == 3U);
+  auto tempo = std::to_string(state.audio.metronome_bpm) + " BPM";
+  if (state.audio.tempo_editing) {
+    tempo = "EDIT " + tempo;
+  }
+  draw_row(context, {.x = bounds.x + 36.0F, .y = list_y + row_height * 4.0F, .width = row_width, .height = row_height}, "Tempo", tempo, state.selected_main_menu_index == 4U);
 }
 
 auto draw_performance_song_menu(luma::draw_context& context, luma::rect bounds, vamp_zero::app_state const& state) -> void {