From e9e608cfa09792a64fbda0946c92ec396622a088 Mon Sep 17 00:00:00 2001 From: jacqueline Date: Mon, 23 Dec 2024 16:08:47 +1100 Subject: Add a new track tag + index for multiple artists We still mostly use the singular 'Artist' tag for e.g. displaying a nice name in the now playing screen, but where a track has an 'ARTISTS=' tag, we'll split by semicolon and then use the resulting list to populate an index of tracks by artist --- src/tangara/database/track.cpp | 51 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) (limited to 'src/tangara/database/track.cpp') diff --git a/src/tangara/database/track.cpp b/src/tangara/database/track.cpp index 49babb6a..f0959c98 100644 --- a/src/tangara/database/track.cpp +++ b/src/tangara/database/track.cpp @@ -20,6 +20,7 @@ namespace database { +static constexpr char kAllArtistDelimiters[] = ";"; static constexpr char kGenreDelimiters[] = ",;"; auto tagName(Tag t) -> std::string { @@ -28,6 +29,8 @@ auto tagName(Tag t) -> std::string { return "title"; case Tag::kArtist: return "artist"; + case Tag::kAllArtists: + return "all_artists"; case Tag::kAlbum: return "album"; case Tag::kAlbumArtist: @@ -111,6 +114,8 @@ auto TrackTags::get(Tag t) const -> TagValue { return valueOrMonostate(title_); case Tag::kArtist: return valueOrMonostate(artist_); + case Tag::kAllArtists: + return allArtists_; case Tag::kAlbum: return valueOrMonostate(album_); case Tag::kAlbumArtist: @@ -135,6 +140,9 @@ auto TrackTags::set(Tag t, std::string_view v) -> void { case Tag::kArtist: artist(v); break; + case Tag::kAllArtists: + allArtists(v); + break; case Tag::kAlbum: album(v); break; @@ -165,6 +173,7 @@ auto TrackTags::allPresent() const -> std::vector { }; add_if_present(Tag::kTitle, title_); add_if_present(Tag::kArtist, artist_); + add_if_present(Tag::kAllArtists, !allArtists_.empty()); add_if_present(Tag::kAlbum, album_); add_if_present(Tag::kAlbumArtist, album_artist_); add_if_present(Tag::kDisc, disc_); @@ -189,6 +198,48 @@ auto TrackTags::artist(std::string_view s) -> void { artist_ = s; } +auto TrackTags::allArtists() const -> std::span { + return allArtists_; +} + +auto TrackTags::allArtists(const std::string_view s) -> void { + allArtists_.clear(); + std::string src = {s.data(), s.size()}; + char* token = std::strtok(src.data(), kAllArtistDelimiters); + + auto trim_and_add = [this](std::string_view s) { + std::string copy = {s.data(), s.size()}; + + // Trim the left + copy.erase(copy.begin(), + std::find_if(copy.begin(), copy.end(), [](unsigned char ch) { + return !std::isspace(ch); + })); + + // Trim the right + copy.erase(std::find_if(copy.rbegin(), copy.rend(), + [](unsigned char ch) { return !std::isspace(ch); }) + .base(), + copy.end()); + + // Ignore empty strings. + if (!copy.empty()) { + allArtists_.push_back({copy.data(), copy.size()}); + } + }; + + if (token == NULL) { + // No delimiters found in the input. Treat this as a single artist. + trim_and_add(s); + } else { + while (token != NULL) { + // Add tokens until no more delimiters found. + trim_and_add(token); + token = std::strtok(NULL, kAllArtistDelimiters); + } + } +} + auto TrackTags::album() const -> const std::optional& { return album_; } -- cgit v1.2.3 From 4a422f4e54959303b0a6083650d2f19a25716a1a Mon Sep 17 00:00:00 2001 From: jacqueline Date: Mon, 23 Dec 2024 16:23:57 +1100 Subject: Use a common code path for parsing delimited track tags --- src/tangara/database/track.cpp | 116 ++++++++++++++++------------------------- 1 file changed, 46 insertions(+), 70 deletions(-) (limited to 'src/tangara/database/track.cpp') diff --git a/src/tangara/database/track.cpp b/src/tangara/database/track.cpp index f0959c98..9f7da2d5 100644 --- a/src/tangara/database/track.cpp +++ b/src/tangara/database/track.cpp @@ -94,6 +94,50 @@ auto tagToString(const TagValue& val) -> std::string { return ""; } +/* + * Utility for taking a string containing delimited tags, and splitting it out + * into a vector of individual tags. + */ +auto parseDelimitedTags(const std::string_view s, + const char* delimiters, + std::pmr::vector& out) -> void { + out.clear(); + std::string src = {s.data(), s.size()}; + char* token = std::strtok(src.data(), delimiters); + + auto trim_and_add = [&](std::string_view s) { + std::string copy = {s.data(), s.size()}; + + // Trim the left + copy.erase(copy.begin(), + std::find_if(copy.begin(), copy.end(), [](unsigned char ch) { + return !std::isspace(ch); + })); + + // Trim the right + copy.erase(std::find_if(copy.rbegin(), copy.rend(), + [](unsigned char ch) { return !std::isspace(ch); }) + .base(), + copy.end()); + + // Ignore empty strings. + if (!copy.empty()) { + out.push_back({copy.data(), copy.size()}); + } + }; + + if (token == NULL) { + // No delimiters found in the input. Treat this as a single result. + trim_and_add(s); + } else { + while (token != NULL) { + // Add tokens until no more delimiters found. + trim_and_add(token); + token = std::strtok(NULL, delimiters); + } + } +} + auto TrackTags::create() -> std::shared_ptr { return std::allocate_shared>( @@ -203,41 +247,7 @@ auto TrackTags::allArtists() const -> std::span { } auto TrackTags::allArtists(const std::string_view s) -> void { - allArtists_.clear(); - std::string src = {s.data(), s.size()}; - char* token = std::strtok(src.data(), kAllArtistDelimiters); - - auto trim_and_add = [this](std::string_view s) { - std::string copy = {s.data(), s.size()}; - - // Trim the left - copy.erase(copy.begin(), - std::find_if(copy.begin(), copy.end(), [](unsigned char ch) { - return !std::isspace(ch); - })); - - // Trim the right - copy.erase(std::find_if(copy.rbegin(), copy.rend(), - [](unsigned char ch) { return !std::isspace(ch); }) - .base(), - copy.end()); - - // Ignore empty strings. - if (!copy.empty()) { - allArtists_.push_back({copy.data(), copy.size()}); - } - }; - - if (token == NULL) { - // No delimiters found in the input. Treat this as a single artist. - trim_and_add(s); - } else { - while (token != NULL) { - // Add tokens until no more delimiters found. - trim_and_add(token); - token = std::strtok(NULL, kAllArtistDelimiters); - } - } + parseDelimitedTags(s, kAllArtistDelimiters, allArtists_); } auto TrackTags::album() const -> const std::optional& { @@ -281,41 +291,7 @@ auto TrackTags::genres() const -> std::span { } auto TrackTags::genres(const std::string_view s) -> void { - genres_.clear(); - std::string src = {s.data(), s.size()}; - char* token = std::strtok(src.data(), kGenreDelimiters); - - auto trim_and_add = [this](std::string_view s) { - std::string copy = {s.data(), s.size()}; - - // Trim the left - copy.erase(copy.begin(), - std::find_if(copy.begin(), copy.end(), [](unsigned char ch) { - return !std::isspace(ch); - })); - - // Trim the right - copy.erase(std::find_if(copy.rbegin(), copy.rend(), - [](unsigned char ch) { return !std::isspace(ch); }) - .base(), - copy.end()); - - // Ignore empty strings. - if (!copy.empty()) { - genres_.push_back({copy.data(), copy.size()}); - } - }; - - if (token == NULL) { - // No delimiters found in the input. Treat this as a single genre. - trim_and_add(s); - } else { - while (token != NULL) { - // Add tokens until no more delimiters found. - trim_and_add(token); - token = std::strtok(NULL, kGenreDelimiters); - } - } + parseDelimitedTags(s, kGenreDelimiters, genres_); } /* -- cgit v1.2.3 From b6b62cb8ea8121a3ae604b508c508a2a4994050a Mon Sep 17 00:00:00 2001 From: jacqueline Date: Tue, 31 Dec 2024 11:30:23 +1100 Subject: Handle synthesizing missing tag values in TrackTags instead of the indexer --- src/tangara/database/track.cpp | 32 ++++++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 8 deletions(-) (limited to 'src/tangara/database/track.cpp') diff --git a/src/tangara/database/track.cpp b/src/tangara/database/track.cpp index 9f7da2d5..ad9db1ba 100644 --- a/src/tangara/database/track.cpp +++ b/src/tangara/database/track.cpp @@ -155,23 +155,23 @@ auto valueOrMonostate(std::optional t) -> TagValue { auto TrackTags::get(Tag t) const -> TagValue { switch (t) { case Tag::kTitle: - return valueOrMonostate(title_); + return valueOrMonostate(title()); case Tag::kArtist: - return valueOrMonostate(artist_); + return valueOrMonostate(artist()); case Tag::kAllArtists: - return allArtists_; + return allArtists(); case Tag::kAlbum: - return valueOrMonostate(album_); + return valueOrMonostate(album()); case Tag::kAlbumArtist: - return valueOrMonostate(album_artist_); + return valueOrMonostate(albumArtist()); case Tag::kDisc: - return valueOrMonostate(disc_); + return valueOrMonostate(disc()); case Tag::kTrack: - return valueOrMonostate(track_); + return valueOrMonostate(track()); case Tag::kAlbumOrder: return albumOrder(); case Tag::kGenres: - return genres_; + return genres(); } return std::monostate{}; } @@ -240,6 +240,7 @@ auto TrackTags::artist() const -> const std::optional& { auto TrackTags::artist(std::string_view s) -> void { artist_ = s; + maybeSynthesizeAllArtists(); } auto TrackTags::allArtists() const -> std::span { @@ -248,6 +249,7 @@ auto TrackTags::allArtists() const -> std::span { auto TrackTags::allArtists(const std::string_view s) -> void { parseDelimitedTags(s, kAllArtistDelimiters, allArtists_); + maybeSynthesizeAllArtists(); } auto TrackTags::album() const -> const std::optional& { @@ -259,6 +261,9 @@ auto TrackTags::album(std::string_view s) -> void { } auto TrackTags::albumArtist() const -> const std::optional& { + if (!album_artist_) { + return artist_; + } return album_artist_; } @@ -320,6 +325,17 @@ auto TrackTags::Hash() const -> uint64_t { return komihash_stream_final(&stream); } +/* + * Adds the current 'artist' tag to 'allArtists' if needed. Many tracks lack a + * fine-grained 'ARTISTS=' tag (or equivalent), but pushing down this nuance to + * consumers of TrackTags adds a lot of complexity. + */ +auto TrackTags::maybeSynthesizeAllArtists() -> void { + if (allArtists_.empty() && artist_) { + allArtists_.push_back(*artist_); + } +} + auto database::TrackData::clone() const -> std::shared_ptr { auto data = std::make_shared(); data->id = id; -- cgit v1.2.3