Playback

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};
 };