From 786546653a062c8270e608524de1c0a7e1fc1e6e Mon Sep 17 00:00:00 2001 From: jacqueline Date: Tue, 13 Feb 2024 12:05:12 +1100 Subject: include repeat, replay, and shuffle in persisted queue info --- src/audio/include/track_queue.hpp | 41 ++++++++++- src/audio/track_queue.cpp | 150 +++++++++++++++++++++++++++----------- 2 files changed, 146 insertions(+), 45 deletions(-) (limited to 'src') diff --git a/src/audio/include/track_queue.hpp b/src/audio/include/track_queue.hpp index fd6061a7..e4fd7881 100644 --- a/src/audio/include/track_queue.hpp +++ b/src/audio/include/track_queue.hpp @@ -12,6 +12,7 @@ #include #include +#include "cppbor_parse.h" #include "database.hpp" #include "tasks.hpp" #include "track.hpp" @@ -24,6 +25,7 @@ namespace audio { */ class RandomIterator { public: + RandomIterator(); RandomIterator(size_t size); auto current() const -> size_t; @@ -35,6 +37,10 @@ class RandomIterator { auto resize(size_t) -> void; auto replay(bool) -> void; + auto seed() -> size_t& { return seed_; } + auto pos() -> size_t& { return pos_; } + auto size() -> size_t& { return size_; } + private: size_t seed_; size_t pos_; @@ -85,12 +91,11 @@ class TrackQueue { auto next() -> void; auto previous() -> void; - /* + /* * Called when the current track finishes */ auto finish() -> void; - auto skipTo(database::TrackId) -> void; /* @@ -125,6 +130,38 @@ class TrackQueue { std::optional shuffle_; bool repeat_; bool replay_; + + class QueueParseClient : public cppbor::ParseClient { + public: + QueueParseClient(TrackQueue& queue); + + ParseClient* item(std::unique_ptr& item, + const uint8_t* hdrBegin, + const uint8_t* valueBegin, + const uint8_t* end) override; + + ParseClient* itemEnd(std::unique_ptr& item, + const uint8_t* hdrBegin, + const uint8_t* valueBegin, + const uint8_t* end) override; + + void error(const uint8_t* position, + const std::string& errorMessage) override {} + + private: + TrackQueue& queue_; + + enum class State { + kInit, + kRoot, + kMetadata, + kShuffle, + kTracks, + kFinished, + }; + State state_; + size_t i_; + }; }; } // namespace audio diff --git a/src/audio/track_queue.cpp b/src/audio/track_queue.cpp index c4c101f6..534da10c 100644 --- a/src/audio/track_queue.cpp +++ b/src/audio/track_queue.cpp @@ -33,6 +33,9 @@ namespace audio { [[maybe_unused]] static constexpr char kTag[] = "tracks"; +RandomIterator::RandomIterator() + : seed_(0), pos_(0), size_(0), replay_(false) {} + RandomIterator::RandomIterator(size_t size) : seed_(), pos_(0), size_(size), replay_(false) { esp_fill_random(&seed_, sizeof(seed_)); @@ -338,66 +341,127 @@ auto TrackQueue::serialise() -> std::string { for (database::TrackId track : tracks_) { tracks.add(cppbor::Uint(track)); } - // FIXME: this should include the RandomIterator's seed as well. - cppbor::Array encoded{ - cppbor::Uint{pos_}, - std::move(tracks), - }; + cppbor::Map encoded; + encoded.add(cppbor::Uint{0}, cppbor::Array{ + cppbor::Uint{pos_}, + cppbor::Bool{repeat_}, + cppbor::Bool{replay_}, + }); + if (shuffle_) { + encoded.add(cppbor::Uint{1}, cppbor::Array{ + cppbor::Uint{shuffle_->size()}, + cppbor::Uint{shuffle_->seed()}, + cppbor::Uint{shuffle_->pos()}, + }); + } + encoded.add(cppbor::Uint{2}, std::move(tracks)); return encoded.toString(); } -class QueueParseClient : public cppbor::ParseClient { - public: - QueueParseClient(size_t& pos, std::pmr::vector& tracks) - : pos_(pos), - tracks_(tracks), - in_root_array_(false), - in_track_list_(false) {} - - ParseClient* item(std::unique_ptr& item, - const uint8_t* hdrBegin, - const uint8_t* valueBegin, - const uint8_t* end) override { +TrackQueue::QueueParseClient::QueueParseClient(TrackQueue& queue) + : queue_(queue), state_(State::kInit), i_(0) {} + +cppbor::ParseClient* TrackQueue::QueueParseClient::item( + std::unique_ptr& item, + const uint8_t* hdrBegin, + const uint8_t* valueBegin, + const uint8_t* end) { + if (state_ == State::kInit) { + if (item->type() == cppbor::MAP) { + state_ = State::kRoot; + } + } else if (state_ == State::kRoot) { + if (item->type() == cppbor::UINT) { + switch (item->asUint()->unsignedValue()) { + case 0: + state_ = State::kMetadata; + break; + case 1: + state_ = State::kShuffle; + break; + case 2: + state_ = State::kTracks; + break; + default: + state_ = State::kFinished; + } + } + } else if (state_ == State::kMetadata) { if (item->type() == cppbor::ARRAY) { - if (!in_root_array_) { - in_root_array_ = true; - } else { - in_track_list_ = true; + i_ = 0; + } else if (item->type() == cppbor::UINT) { + queue_.pos_ = item->asUint()->unsignedValue(); + } else if (item->type() == cppbor::SIMPLE) { + bool val = item->asBool()->value(); + if (i_ == 0) { + queue_.repeat_ = val; + } else if (i_ == 1) { + queue_.replay_ = val; } + i_++; + } + } else if (state_ == State::kShuffle) { + if (item->type() == cppbor::ARRAY) { + i_ = 0; + queue_.shuffle_.emplace(); + queue_.shuffle_->replay(queue_.replay_); } else if (item->type() == cppbor::UINT) { auto val = item->asUint()->unsignedValue(); - if (in_track_list_) { - tracks_.push_back(val); - } else { - pos_ = static_cast(val); + switch (i_) { + case 0: + queue_.shuffle_->size() = val; + break; + case 1: + queue_.shuffle_->seed() = val; + break; + case 2: + queue_.shuffle_->pos() = val; + break; + default: + break; } + i_++; } - return this; + } else if (state_ == State::kTracks) { + if (item->type() == cppbor::UINT) { + queue_.tracks_.push_back(item->asUint()->unsignedValue()); + } + } else if (state_ == State::kFinished) { } + return this; +} - ParseClient* itemEnd(std::unique_ptr& item, - const uint8_t* hdrBegin, - const uint8_t* valueBegin, - const uint8_t* end) override { - return this; +cppbor::ParseClient* TrackQueue::QueueParseClient::itemEnd( + std::unique_ptr& item, + const uint8_t* hdrBegin, + const uint8_t* valueBegin, + const uint8_t* end) { + if (state_ == State::kInit) { + state_ = State::kFinished; + } else if (state_ == State::kRoot) { + state_ = State::kFinished; + } else if (state_ == State::kMetadata) { + if (item->type() == cppbor::ARRAY) { + state_ = State::kRoot; + } + } else if (state_ == State::kShuffle) { + if (item->type() == cppbor::ARRAY) { + state_ = State::kRoot; + } + } else if (state_ == State::kTracks) { + if (item->type() == cppbor::ARRAY) { + state_ = State::kRoot; + } + } else if (state_ == State::kFinished) { } - - void error(const uint8_t* position, - const std::string& errorMessage) override {} - - private: - size_t& pos_; - std::pmr::vector& tracks_; - - bool in_root_array_; - bool in_track_list_; -}; + return this; +} auto TrackQueue::deserialise(const std::string& s) -> void { if (s.empty()) { return; } - QueueParseClient client{pos_, tracks_}; + QueueParseClient client{*this}; const uint8_t* data = reinterpret_cast(s.data()); cppbor::parse(data, data + s.size(), &client); notifyChanged(true); -- cgit v1.2.3 From b31bc07555fdd862181d8d6ed551163cea89bc62 Mon Sep 17 00:00:00 2001 From: jacqueline Date: Tue, 13 Feb 2024 16:39:56 +1100 Subject: fix (improve?) libtremor strangeness something fucky --- src/codecs/include/vorbis.hpp | 2 +- src/codecs/vorbis.cpp | 25 +++++++++++++++---------- 2 files changed, 16 insertions(+), 11 deletions(-) (limited to 'src') diff --git a/src/codecs/include/vorbis.hpp b/src/codecs/include/vorbis.hpp index 2f93c37e..673b67a0 100644 --- a/src/codecs/include/vorbis.hpp +++ b/src/codecs/include/vorbis.hpp @@ -41,7 +41,7 @@ class TremorVorbisDecoder : public ICodec { private: std::shared_ptr input_; - OggVorbis_File vorbis_; + std::unique_ptr vorbis_; }; } // namespace codecs diff --git a/src/codecs/vorbis.cpp b/src/codecs/vorbis.cpp index 3b3798cb..c373ebf5 100644 --- a/src/codecs/vorbis.cpp +++ b/src/codecs/vorbis.cpp @@ -78,17 +78,21 @@ static const ov_callbacks kCallbacks{ .tell_func = tell_cb, // Not seekable }; -TremorVorbisDecoder::TremorVorbisDecoder() : input_(), vorbis_() {} +TremorVorbisDecoder::TremorVorbisDecoder() + : input_(), + vorbis_(reinterpret_cast( + heap_caps_malloc(sizeof(OggVorbis_File), + MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT))) {} TremorVorbisDecoder::~TremorVorbisDecoder() { - ov_clear(&vorbis_); + ov_clear(vorbis_.get()); } auto TremorVorbisDecoder::OpenStream(std::shared_ptr input) -> cpp::result { - int res = ov_open_callbacks(input.get(), &vorbis_, NULL, 0, kCallbacks); + int res = ov_open_callbacks(input.get(), vorbis_.get(), NULL, 0, kCallbacks); if (res < 0) { - std::pmr::string err; + std::string err; switch (res) { case OV_EREAD: err = "OV_EREAD"; @@ -112,13 +116,13 @@ auto TremorVorbisDecoder::OpenStream(std::shared_ptr input) return cpp::fail(Error::kMalformedData); } - vorbis_info* info = ov_info(&vorbis_, -1); + vorbis_info* info = ov_info(vorbis_.get(), -1); if (info == NULL) { ESP_LOGE(kTag, "failed to get stream info"); return cpp::fail(Error::kMalformedData); } - auto l = ov_pcm_total(&vorbis_, -1); + auto l = ov_pcm_total(vorbis_.get(), -1); std::optional length; if (l > 0) { length = l * info->channels; @@ -133,9 +137,10 @@ auto TremorVorbisDecoder::OpenStream(std::shared_ptr input) auto TremorVorbisDecoder::DecodeTo(cpp::span output) -> cpp::result { - int bitstream = 0; - long bytes_written = ov_read(&vorbis_, reinterpret_cast(output.data()), - output.size_bytes(), &bitstream); + int unused = 0; + long bytes_written = + ov_read(vorbis_.get(), reinterpret_cast(output.data()), + ((output.size() - 1) * sizeof(sample::Sample)), &unused); if (bytes_written == OV_HOLE) { ESP_LOGE(kTag, "got OV_HOLE"); return cpp::fail(Error::kMalformedData); @@ -152,7 +157,7 @@ auto TremorVorbisDecoder::DecodeTo(cpp::span output) } auto TremorVorbisDecoder::SeekTo(size_t target) -> cpp::result { - if (ov_pcm_seek(&vorbis_, target) != 0) { + if (ov_pcm_seek(vorbis_.get(), target) != 0) { return cpp::fail(Error::kInternalError); } return {}; -- cgit v1.2.3 From 7ec0ff2589ffd5774e78f9e6b436ea55be45deb1 Mon Sep 17 00:00:00 2001 From: jacqueline Date: Wed, 14 Feb 2024 12:21:33 +1100 Subject: Switch to the lowmem tremor branch in addition to using slightly less memory, this branch also doesn't seem to have the same issues with `-O2` builds that the main branch has. --- src/codecs/include/vorbis.hpp | 4 +--- src/codecs/vorbis.cpp | 25 +++++++------------------ 2 files changed, 8 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/codecs/include/vorbis.hpp b/src/codecs/include/vorbis.hpp index 673b67a0..b96a0407 100644 --- a/src/codecs/include/vorbis.hpp +++ b/src/codecs/include/vorbis.hpp @@ -14,8 +14,6 @@ #include #include "ivorbisfile.h" -#include "ogg/ogg.h" -#include "opus.h" #include "sample.hpp" #include "span.hpp" @@ -41,7 +39,7 @@ class TremorVorbisDecoder : public ICodec { private: std::shared_ptr input_; - std::unique_ptr vorbis_; + std::unique_ptr vorbis_; }; } // namespace codecs diff --git a/src/codecs/vorbis.cpp b/src/codecs/vorbis.cpp index c373ebf5..7fb53f1b 100644 --- a/src/codecs/vorbis.cpp +++ b/src/codecs/vorbis.cpp @@ -4,31 +4,20 @@ * SPDX-License-Identifier: GPL-3.0-only */ -#include "ivorbiscodec.h" -#include "ivorbisfile.h" -#include "ogg/config_types.h" -#include "opus.hpp" - -#include -#include +#include "vorbis.hpp" #include #include #include #include "esp_heap_caps.h" -#include "mad.h" +#include "esp_log.h" +#include "ivorbiscodec.h" +#include "ivorbisfile.h" #include "codec.hpp" -#include "esp_log.h" -#include "ogg/ogg.h" -#include "opus.h" -#include "opus_defines.h" -#include "opus_types.h" -#include "result.hpp" #include "sample.hpp" #include "types.hpp" -#include "vorbis.hpp" namespace codecs { @@ -39,7 +28,7 @@ static size_t read_cb(void* ptr, size_t size, size_t nmemb, void* instance) { return source->Read({reinterpret_cast(ptr), size * nmemb}); } -static int seek_cb(void* instance, ogg_int64_t offset, int whence) { +static int seek_cb(void* instance, tremor_ogg_int64_t offset, int whence) { IStream* source = reinterpret_cast(instance); if (!source->CanSeek()) { return -1; @@ -80,8 +69,8 @@ static const ov_callbacks kCallbacks{ TremorVorbisDecoder::TremorVorbisDecoder() : input_(), - vorbis_(reinterpret_cast( - heap_caps_malloc(sizeof(OggVorbis_File), + vorbis_(reinterpret_cast( + heap_caps_malloc(sizeof(TremorOggVorbis_File), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT))) {} TremorVorbisDecoder::~TremorVorbisDecoder() { -- cgit v1.2.3 From 4bc77f901b1597b7cbc9ab7f4e0e354a7c93ed43 Mon Sep 17 00:00:00 2001 From: jacqueline Date: Wed, 14 Feb 2024 16:56:49 +1100 Subject: Tweak opus build flags and allocs This gets us to ~40% of one core cpu usage during playback. Good enough for a while I reckon! Paid for the internal ram usage by reclaiming some stack size headroom. --- src/dev_console/include/console.hpp | 2 +- src/tasks/tasks.cpp | 12 +++++------- 2 files changed, 6 insertions(+), 8 deletions(-) (limited to 'src') diff --git a/src/dev_console/include/console.hpp b/src/dev_console/include/console.hpp index fd4050c2..fedf3632 100644 --- a/src/dev_console/include/console.hpp +++ b/src/dev_console/include/console.hpp @@ -18,7 +18,7 @@ class Console { auto Launch() -> void; protected: - virtual auto GetStackSizeKiB() -> uint16_t { return 16; } + virtual auto GetStackSizeKiB() -> uint16_t { return 8; } virtual auto RegisterExtraComponents() -> void {} private: diff --git a/src/tasks/tasks.cpp b/src/tasks/tasks.cpp index d53eface..aa382655 100644 --- a/src/tasks/tasks.cpp +++ b/src/tasks/tasks.cpp @@ -39,22 +39,20 @@ auto AllocateStack() -> cpp::span; // usually written with embedded use cases in mind. template <> auto AllocateStack() -> cpp::span { - constexpr std::size_t size = 24 * 1024; + constexpr std::size_t size = 20 * 1024; static StackType_t sStack[size]; return {sStack, size}; } -// LVGL requires only a relatively small stack. However, it can be allocated in -// PSRAM so we give it a bit of headroom for safety. +// LVGL requires only a relatively small stack. Lua's stack is allocated +// separately. template <> auto AllocateStack() -> cpp::span { - constexpr std::size_t size = 16 * 1024; + constexpr std::size_t size = 14 * 1024; static StackType_t sStack[size]; return {sStack, size}; } template <> -// PCM conversion and resampling uses a very small amount of stack. It works -// entirely with PSRAM-allocated buffers, so no real speed gain from allocating -// it internally. +// PCM conversion and resampling uses a very small amount of stack. auto AllocateStack() -> cpp::span { constexpr std::size_t size = 4 * 1024; static StackType_t sStack[size]; -- cgit v1.2.3 From c5917658e6a0fcc77971237c80bb4e47f3e8bf9e Mon Sep 17 00:00:00 2001 From: jacqueline Date: Wed, 14 Feb 2024 17:48:13 +1100 Subject: Cram one of the flac samples buffers into internal ram Can't quite fit the second... yet. Just one is a pretty reasonable speedup, though! Probably bc we're not hammering the spiram cache so hard. --- src/codecs/miniflac.cpp | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/codecs/miniflac.cpp b/src/codecs/miniflac.cpp index ace73466..74eafb3b 100644 --- a/src/codecs/miniflac.cpp +++ b/src/codecs/miniflac.cpp @@ -30,9 +30,16 @@ MiniFlacDecoder::MiniFlacDecoder() current_sample_() { miniflac_init(flac_.get(), MINIFLAC_CONTAINER_UNKNOWN); for (int i = 0; i < samples_by_channel_.size(); i++) { - // Full decoded frames too big to fit in internal ram :( + uint32_t caps; + if (i == 0) { + caps = MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL; + } else { + // FIXME: We can *almost* fit two channels into internal ram, but we're a + // few KiB shy of being able to do it safely. + caps = MALLOC_CAP_SPIRAM; + } samples_by_channel_[i] = reinterpret_cast( - heap_caps_malloc(kMaxFrameSize * sizeof(int32_t), MALLOC_CAP_SPIRAM)); + heap_caps_malloc(kMaxFrameSize * sizeof(int32_t), caps)); } } -- cgit v1.2.3