Playback

include/vamp_pico/artwork.hpp

@@ -42,13 +42,19 @@ enum class sprite : std::size_t {
   MAIN_MENU,
   PERFORMANCE,
   SETTINGS,
-  PLAYBACK,
+  BACKING,
   METRONOME,
   TEMPO,
   BACK,
   ON,
   OFF,
   BPM,
+  MANUAL,
+  PREPARING,
+  COUNT_IN,
+  PLAYING,
+  SUSTAIN,
+  HOLD_TO_EXIT,
   DIGIT_0,
   DIGIT_1,
   DIGIT_2,

include/vamp_pico/http_client.hpp

@@ -20,7 +20,10 @@ struct remote_display_state {
   std::char_t part[48]{};
   std::char_t mode[24]{};
   std::char_t focus[32]{};
-  std::bool_t playback{};
+  std::bool_t backing{};
+  std::bool_t backing_available{true};
+  std::bool_t error{};
+  std::array<std::char_t, 16> phase{};
   std::bool_t metronome{};
   std::bool_t editing{};
   std::uint32_t bpm{120U};
@@ -28,7 +31,7 @@ struct remote_display_state {
   std::uint32_t page{};
   std::uint32_t pages{};
   auto operator==(remote_display_state const &other) const -> std::bool_t {
-    return active == other.active && std::string_view{title} == other.title && std::string_view{part} == other.part && std::string_view{mode} == other.mode && std::string_view{focus} == other.focus && playback == other.playback && metronome == other.metronome && editing == other.editing && bpm == other.bpm && title_image == other.title_image && page == other.page && pages == other.pages;
+    return backing_available == other.backing_available && error == other.error && phase == other.phase && active == other.active && std::string_view{title} == other.title && std::string_view{part} == other.part && std::string_view{mode} == other.mode && std::string_view{focus} == other.focus && backing == other.backing && metronome == other.metronome && editing == other.editing && bpm == other.bpm && title_image == other.title_image && page == other.page && pages == other.pages;
   }
 };
 

include/vamp_zero/audio.hpp

@@ -16,6 +16,7 @@
 #include <vamp_zero/config.hpp>
 #include <vamp_zero/types.hpp>
 #include <vamp_zero/score_loader.hpp>
+#include <vamp_zero/performance.hpp>
 
 
 namespace vamp_zero {
@@ -28,19 +29,18 @@ public:
   ~audio_controller();
   auto sync(vamp_zero::app_state const &state) -> void;
   auto tick(vamp_zero::app_state const &state, vamp_zero::score_load_state const &loaded, std::filesystem::path const &assets) -> std::optional<std::expected<void, modulus::error>>;
+  auto position(vamp_zero::score_document const &score, std::uint32_t bpm) const -> std::optional<vamp_zero::performance_position>;
 private:
-  auto make_metronome_config(vamp_zero::app_state const &state) const -> sonus::metronome_config;
   vamp_zero::audio_config config_{};
   sonus::engine engine_;
   mutable std::mutex mutex_{};
-  std::bool_t metronome_running_{false};
-  std::uint32_t last_metronome_bpm_{};
   boost::asio::thread_pool worker_{1};
-  std::future<std::expected<sonus::prepared_sequence, modulus::error>> preparation_{};
+  std::future<std::expected<sonus::prepared_transport, modulus::error>> preparation_{};
   std::uint64_t preparing_session_{};
+  std::shared_ptr<vamp_zero::catalog const> preparing_catalog_{};
   std::optional<std::uint64_t> attempted_session_{};
   std::shared_ptr<vamp_zero::catalog const> catalog_{};
-  sonus::playback_session playback_{};
+  sonus::transport_session playback_{};
   std::bool_t reported_{true};
 };
 

include/vamp_zero/config.hpp

@@ -46,13 +46,9 @@ struct control_config {
 
 struct audio_config {
   std::bool_t enabled{true};
-  std::bool_t playback_enabled{false};
+  std::bool_t backing_enabled{false};
   std::bool_t metronome_enabled{false};
-  std::uint32_t metronome_bpm{120};
-  std::uint32_t metronome_min_bpm{40};
-  std::uint32_t metronome_max_bpm{240};
-  std::uint32_t metronome_step{5};
-  std::uint32_t beats_per_bar{4};
+  std::uint32_t tempo_bpm{120};
   std::float32_t master_volume{0.70F};
   std::float32_t metronome_volume{0.45F};
 };

include/vamp_zero/control.hpp

@@ -25,6 +25,7 @@ public:
   auto refresh_connection() -> std::optional<vamp_zero::app_state>;
   auto set_observer(std::function<void(vamp_zero::app_state)> observer) -> void;
   auto finish_playback(std::uint64_t session, std::string error = {}, std::shared_ptr<vamp_zero::catalog const> catalog = {}) -> void;
+  auto update_performance(std::uint64_t session, std::size_t page, std::string phase, std::shared_ptr<vamp_zero::catalog const> catalog) -> void;
 private:
   auto pico_connected_locked() const -> std::bool_t;
   auto snapshot_locked() const -> vamp_zero::app_state;

include/vamp_zero/performance.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <expected>
+#include <filesystem>
+#include <string_view>
+#include <boost/json.hpp>
+#include <sonus.hpp>
+#include <vamp_zero/types.hpp>
+
+
+namespace vamp_zero {
+
+auto parse_beat(boost::json::value const &value) -> std::expected<vamp_zero::beat_position, modulus::error>;
+auto frame_at(vamp_zero::beat_position beat, std::uint32_t bpm) -> std::uint64_t;
+auto available_tempos(vamp_zero::app_state const &state) -> std::vector<std::uint32_t>;
+auto parse_audio_assets(std::string_view json) -> std::expected<std::vector<vamp_zero::audio_asset>, modulus::error>;
+auto validate_audio_assets(vamp_zero::catalog const &catalog, std::filesystem::path const &assets) -> std::expected<void, modulus::error>;
+auto prepare_performance(vamp_zero::score_document const &score, vamp_zero::app_state const &state, std::filesystem::path const &assets, std::float32_t click_volume) -> std::expected<sonus::prepared_transport, modulus::error>;
+
+struct performance_position {
+  std::size_t page{};
+  std::string phase{};
+};
+
+auto performance_at(vamp_zero::score_document const &score, std::uint64_t frames, std::uint32_t bpm) -> vamp_zero::performance_position;
+auto automatic(vamp_zero::audio_state const &audio) -> bool;
+
+}

include/vamp_zero/playback.hpp

@@ -1,18 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <expected>
-#include <filesystem>
-
-#include <modulus.hpp>
-#include <sonus.hpp>
-
-#include <vamp_zero/types.hpp>
-
-
-namespace vamp_zero {
-
-auto prepare_playback(vamp_zero::score_document const &score, std::filesystem::path const &assets, std::uint32_t bpm) -> std::expected<sonus::sample_sequence, modulus::error>;
-auto validate_playback_assets(vamp_zero::score_document const &score, std::filesystem::path const &assets) -> std::expected<void, modulus::error>;
-
-}

include/vamp_zero/score_loader.hpp

@@ -17,6 +17,7 @@ struct score_load_state {
   std::shared_ptr<vamp_zero::score_document const> document{};
   std::optional<modulus::error> error{};
   std::bool_t loading{};
+  std::bool_t pages_ready{};
 };
 
 class score_loader {
@@ -31,6 +32,7 @@ public:
   auto select(std::shared_ptr<vamp_zero::catalog const> catalog, std::optional<vamp_zero::score_reference> reference) -> void;
   auto snapshot() const -> vamp_zero::score_load_state;
   auto stop() -> void;
+  auto pages_prepared(std::shared_ptr<vamp_zero::score_document const> const &document, std::expected<void, modulus::error> result) -> void;
 private:
   struct state;
   std::shared_ptr<state> state_;

include/vamp_zero/types.hpp

@@ -11,9 +11,18 @@
 
 namespace vamp_zero {
 
+struct beat_position {
+  std::uint64_t numerator{};
+  std::uint64_t denominator{1};
+};
+
 struct score_page {
   std::string path{};
   std::string sha256{};
+  std::size_t first_measure{};
+  std::size_t measure_count{};
+  vamp_zero::beat_position start_beat{};
+  vamp_zero::beat_position end_beat{};
 };
 
 struct score_document {
@@ -28,6 +37,9 @@ struct score_document {
   std::string source_json{};
   std::size_t measure_count{};
   std::vector<vamp_zero::score_page> pages{};
+  std::string song_id{};
+  vamp_zero::beat_position duration{};
+  std::uint32_t count_in_beats{4};
 };
 
 struct library_part {
@@ -40,6 +52,7 @@ struct library_part {
   std::size_t measure_count{};
   std::size_t total_pages{};
   std::string title_image{};
+  std::string song_id{};
 };
 
 struct song_group {
@@ -48,9 +61,20 @@ struct song_group {
   std::vector<std::size_t> parts{};
 };
 
+struct audio_asset {
+  std::string path{};
+  std::string sha256{};
+  std::string song_id{};
+  std::uint32_t bpm{};
+  std::uint32_t sample_rate{};
+  std::uint32_t channels{};
+  std::uint64_t frames{};
+};
+
 struct catalog {
   std::vector<vamp_zero::library_part> parts{};
   std::vector<vamp_zero::song_group> groups{};
+  std::vector<vamp_zero::audio_asset> audio_assets{};
 };
 
 auto empty_catalog() -> std::shared_ptr<vamp_zero::catalog const> const &;
@@ -70,12 +94,10 @@ enum class app_mode {
 
 struct audio_state {
   std::string playback_error{};
-  std::bool_t playback_enabled{false};
+  std::string phase{"Manual"};
+  std::bool_t backing_enabled{false};
   std::bool_t metronome_enabled{false};
-  std::uint32_t metronome_bpm{120};
-  std::uint32_t metronome_min_bpm{40};
-  std::uint32_t metronome_max_bpm{240};
-  std::uint32_t metronome_step{5};
+  std::uint32_t tempo_bpm{120};
   std::bool_t tempo_editing{false};
 };