Funkwhale
/
Clementine-audio-player-Mac-Linux-Windows
mirror of https://github.com/clementine-player/Clementine
1
0
Fork 0
Code Issues Releases Wiki Activity

CddaSongLoader now reads CD-Text for metadata 

currently this gets overwritten by musicbrainz response almost immediately, though
This commit is contained in:
Lukas Prediger 2021-05-21 20:52:29 +03:00 committed by John Maguire
parent b020171da7
commit 90ec6f6a24
4 changed files with 236 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/devices/cddadevice.cpp
View File

@ -32,11 +32,7 @@ CddaDevice::CddaDevice(const QUrl& url, DeviceLister* lister,
cdio_(nullptr),
disc_changed_timer_(),
cdda_song_loader_(url) {
connect(&cdda_song_loader_, SIGNAL(SongsLoaded(SongList)), this,
SLOT(SongsLoaded(SongList)));
connect(&cdda_song_loader_, SIGNAL(SongsDurationLoaded(SongList)), this,
SLOT(SongsLoaded(SongList)));
connect(&cdda_song_loader_, SIGNAL(SongsMetadataLoaded(SongList)), this,
connect(&cdda_song_loader_, SIGNAL(SongsUpdated(SongList)), this,
SLOT(SongsLoaded(SongList)));
connect(this, SIGNAL(SongsDiscovered(SongList)), model_,
SLOT(SongsDiscovered(SongList)));

233
src/devices/cddasongloader.cpp
View File

@ -1,5 +1,6 @@
/* This file is part of Clementine.
Copyright 2014, David Sansome <me@davidsansome.com>
Copyright 2021, Lukas Prediger <lumip@lumip.de>
Clementine is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -27,9 +28,21 @@
#include "core/timeconstants.h"
CddaSongLoader::CddaSongLoader(const QUrl& url, QObject* parent)
: QObject(parent), url_(url), cdda_(nullptr), may_load_(true) {
connect(this, SIGNAL(MusicBrainzDiscIdLoaded(const QString&)),
SLOT(LoadAudioCDTags(const QString&)));
: QObject(parent), url_(url), cdda_(nullptr), may_load_(true), disc_() {
connect(this, &CddaSongLoader::MusicBrainzDiscIdLoaded, this,
&CddaSongLoader::LoadAudioCDTags);
connect(this, &CddaSongLoader::SongsLoaded,
[this](const SongList& song_list) {
SetDiscTracks(song_list, /*has_titles=*/false);
});
connect(this, &CddaSongLoader::SongsDurationLoaded,
[this](const SongList& song_list) {
SetDiscTracks(song_list, /*has_titles=*/false);
});
connect(this, &CddaSongLoader::SongsMetadataLoaded,
[this](const SongList& song_list) {
SetDiscTracks(song_list, /*has_titles=*/true);
});
}
CddaSongLoader::~CddaSongLoader() {
@ -55,17 +68,90 @@ bool CddaSongLoader::IsActive() const { return loading_future_.isRunning(); }
void CddaSongLoader::LoadSongs() {
// only dispatch a new thread for loading tracks if not already running.
if (!IsActive()) {
disc_ = Disc();
loading_future_ =
QtConcurrent::run(this, &CddaSongLoader::LoadSongsFromCdda);
}
}
bool CddaSongLoader::ParseSongTags(SongList& songs, GstTagList* tags,
gint* track_no) {
//// cdiocddasrc reads cd-text with following mapping from cdio
///
/// DISC LEVEL :
/// CDTEXT_FIELD_PERFORMER -> GST_TAG_ALBUM_ARTIST
/// CDTEXT_FIELD_TITLE -> GST_TAG_ALBUM
/// CDTEXT_FIELD_GENRE -> GST_TAG_GENRE
///
/// TRACK LEVEL :
/// CDTEXT_FIELD_PERFORMER -> GST_TAG_ARTIST
/// CDTEXT_FIELD_TITLE -> GST_TAG_TITLE
guint track_number;
if (!gst_tag_list_get_uint(tags, GST_TAG_TRACK_NUMBER, &track_number)) {
qLog(Error) << "Track tags do not contain track number!";
return false;
}
Q_ASSERT(track_number != 0u);
Q_ASSERT(static_cast<int>(track_number) <= songs.size());
Song& song = songs[static_cast<int>(track_number - 1)];
*track_no = static_cast<gint>(track_number) - 1;
// qLog(Debug) << gst_tag_list_to_string(tags);
bool has_loaded_tags = false;
gchar* buffer = nullptr;
if (gst_tag_list_get_string(tags, GST_TAG_ALBUM, &buffer)) {
has_loaded_tags = true;
song.set_album(QString::fromUtf8(buffer));
g_free(buffer);
}
if (gst_tag_list_get_string(tags, GST_TAG_ALBUM_ARTIST, &buffer)) {
has_loaded_tags = true;
song.set_albumartist(QString::fromUtf8(buffer));
g_free(buffer);
}
if (gst_tag_list_get_string(tags, GST_TAG_GENRE, &buffer)) {
has_loaded_tags = true;
song.set_genre(QString::fromUtf8(buffer));
g_free(buffer);
}
if (gst_tag_list_get_string(tags, GST_TAG_ARTIST, &buffer)) {
has_loaded_tags = true;
song.set_artist(QString::fromUtf8(buffer));
g_free(buffer);
}
if (gst_tag_list_get_string(tags, GST_TAG_TITLE, &buffer)) {
has_loaded_tags = true;
song.set_title(QString::fromUtf8(buffer));
g_free(buffer);
}
guint64 duration;
if (gst_tag_list_get_uint64(tags, GST_TAG_DURATION, &duration)) {
has_loaded_tags = true;
song.set_length_nanosec(duration);
}
song.set_track(track_number);
song.set_id(track_number);
song.set_filetype(Song::Type_Cdda);
song.set_valid(true);
song.set_url(GetUrlFromTrack(track_number));
return has_loaded_tags;
}
void CddaSongLoader::LoadSongsFromCdda() {
if (!may_load_) return;
// Create gstreamer cdda element
GError* error = nullptr;
cdda_ = gst_element_make_from_uri(GST_URI_SRC, "cdda://", nullptr, &error);
GstElement* cdda_ = gst_element_factory_make("cdiocddasrc", nullptr);
if (error) {
qLog(Error) << error->code << QString::fromLocal8Bit(error->message);
}
@ -93,17 +179,15 @@ void CddaSongLoader::LoadSongsFromCdda() {
}
// Get number of tracks
GstFormat fmt = gst_format_get_by_nick("track");
GstFormat out_fmt = fmt;
GstFormat track_fmt = gst_format_get_by_nick("track");
gint64 num_tracks = 0;
if (!gst_element_query_duration(cdda_, out_fmt, &num_tracks) ||
out_fmt != fmt) {
qLog(Error) << "Error while querying cdda GstElement";
if (!gst_element_query_duration(cdda_, track_fmt, &num_tracks)) {
qLog(Error) << "Error while querying cdda GstElement for track count";
gst_object_unref(GST_OBJECT(cdda_));
return;
}
SongList songs;
SongList initial_song_list;
for (int track_number = 1; track_number <= num_tracks; track_number++) {
// Init song
Song song;
@ -113,9 +197,11 @@ void CddaSongLoader::LoadSongsFromCdda() {
song.set_url(GetUrlFromTrack(track_number));
song.set_title(QString("Track %1").arg(track_number));
song.set_track(track_number);
songs << song;
initial_song_list << song;
}
emit SongsLoaded(songs);
emit SongsLoaded(initial_song_list);
SongList tagged_song_list(initial_song_list);
gst_tag_register_musicbrainz_tags();
@ -131,6 +217,7 @@ void CddaSongLoader::LoadSongsFromCdda() {
GstMessageType msg_filter =
static_cast<GstMessageType>(GST_MESSAGE_TOC | GST_MESSAGE_TAG);
QString musicbrainz_discid;
bool loaded_cd_tags = false;
while (may_load_ && msg_filter &&
(msg = gst_bus_timed_pop_filtered(GST_ELEMENT_BUS(pipeline),
10 * GST_SECOND, msg_filter))) {
@ -140,7 +227,7 @@ void CddaSongLoader::LoadSongsFromCdda() {
gst_message_parse_toc(msg, &toc, nullptr);
if (toc) {
GList* entries = gst_toc_get_entries(toc);
if (entries && songs.size() <= g_list_length(entries)) {
if (entries && initial_song_list.size() <= g_list_length(entries)) {
int i = 0;
for (GList* node = entries; node != nullptr; node = node->next) {
GstTocEntry* entry = static_cast<GstTocEntry*>(node->data);
@ -148,35 +235,83 @@ void CddaSongLoader::LoadSongsFromCdda() {
gint64 start, stop;
if (gst_toc_entry_get_start_stop_times(entry, &start, &stop))
duration = stop - start;
songs[i++].set_length_nanosec(duration);
initial_song_list[i++].set_length_nanosec(duration);
}
emit SongsDurationLoaded(songs);
emit SongsDurationLoaded(initial_song_list);
msg_filter = static_cast<GstMessageType>(
static_cast<int>(msg_filter) ^ GST_MESSAGE_TOC);
}
gst_toc_unref(toc);
}
} else if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_TAG) {
// Handle TAG message: generate MusicBrainz DiscId
// Handle TAG message: generate MusicBrainz DiscId and read CD-TEXT if
// present
gint64
track_number_from_query; // track number gstreamer thinks we are at
gst_element_query_position(cdda_, track_fmt, &track_number_from_query);
GstTagList* tags = nullptr;
gst_message_parse_tag(msg, &tags);
char* string_mb = nullptr;
if (gst_tag_list_get_string(tags, GST_TAG_CDDA_MUSICBRAINZ_DISCID,
if (musicbrainz_discid.isEmpty() &&
gst_tag_list_get_string(tags, GST_TAG_CDDA_MUSICBRAINZ_DISCID,
&string_mb)) {
QString musicbrainz_discid = QString::fromUtf8(string_mb);
musicbrainz_discid = QString::fromUtf8(string_mb);
g_free(string_mb);
qLog(Info) << "MusicBrainz discid: " << musicbrainz_discid;
emit MusicBrainzDiscIdLoaded(musicbrainz_discid);
// emit MusicBrainzDiscIdLoaded(musicbrainz_discid);
// for now, we'll invoke musicbrainz only after having read all CD-TEXT
// tags and emitted a message for it
}
gint track_number_from_tags; // track number contained in the tag message
loaded_cd_tags |=
ParseSongTags(tagged_song_list, tags, &track_number_from_tags);
gst_tag_list_free(tags);
// We may receive a tag message for a track we have already seen, not for
// the track we seeked to previously, i.e., track_number_from_tags and
// track_number_from_query do not agree. If we would just wait now,
// nothing else would happen: It seems, gstreamer will for some reason not
// pass the tag message for the song we seeked to in this case or it gets
// lost somewhere. We can't seek again to the track we want to see,
// because gstreamer thinks we are already there and will do nothing. We
// therefore seek to the previous track and resume from there.
// note(lumip): There's a slight risk of an infinite loop here where if
// the above behavior repeats consistently, but in my tests this does not
// happen.
if (track_number_from_tags < track_number_from_query) {
qLog(Debug) << "message query mismatch! : " << track_number_from_tags
<< " vs " << track_number_from_query;
gst_element_seek_simple(
pipeline, track_fmt,
static_cast<GstSeekFlags>(GST_SEEK_FLAG_FLUSH |
GST_SEEK_FLAG_TRICKMODE),
track_number_from_tags);
continue;
}
gint next_track_number = track_number_from_tags + 1;
if (next_track_number < num_tracks) {
// more to go, seek to next track to get a tag message for it
gst_element_seek_simple(
pipeline, track_fmt,
static_cast<GstSeekFlags>(GST_SEEK_FLAG_FLUSH |
GST_SEEK_FLAG_TRICKMODE),
next_track_number);
} else // we are done with reading track tags: do no longer filter
msg_filter = static_cast<GstMessageType>(static_cast<int>(msg_filter) ^
GST_MESSAGE_TAG);
}
gst_tag_list_free(tags);
}
gst_message_unref(msg);
}
if (loaded_cd_tags) emit SongsMetadataLoaded(tagged_song_list);
if (!musicbrainz_discid.isEmpty())
emit MusicBrainzDiscIdLoaded(musicbrainz_discid);
// cleanup
gst_element_set_state(pipeline, GST_STATE_NULL);
// This will also cause cdda_ to be unref'd.
gst_object_unref(pipeline);
@ -187,36 +322,46 @@ void CddaSongLoader::LoadAudioCDTags(const QString& musicbrainz_discid) const {
connect(musicbrainz_client,
SIGNAL(Finished(const QString&, const QString&,
MusicBrainzClient::ResultList)),
SLOT(AudioCDTagsLoaded(const QString&, const QString&,
MusicBrainzClient::ResultList)));
SLOT(ProcessMusicBrainzResponse(const QString&, const QString&,
MusicBrainzClient::ResultList)));
musicbrainz_client->StartDiscIdRequest(musicbrainz_discid);
}
void CddaSongLoader::AudioCDTagsLoaded(
void CddaSongLoader::ProcessMusicBrainzResponse(
const QString& artist, const QString& album,
const MusicBrainzClient::ResultList& results) {
MusicBrainzClient* musicbrainz_client =
qobject_cast<MusicBrainzClient*>(sender());
musicbrainz_client->deleteLater();
SongList songs;
if (results.empty()) return;
int track_number = 1;
for (const MusicBrainzClient::Result& ret : results) {
Song song;
song.set_artist(artist);
song.set_album(album);
song.set_title(ret.title_);
song.set_length_nanosec(ret.duration_msec_ * kNsecPerMsec);
song.set_track(track_number);
song.set_year(ret.year_);
song.set_id(track_number);
song.set_filetype(Song::Type_Cdda);
song.set_valid(true);
// We need to set url: that's how playlist will find the correct item to
// update
song.set_url(GetUrlFromTrack(track_number++));
songs << song;
if (disc_.tracks.length() != results.length()) {
qLog(Warning) << "Number of tracks in metadata does not match number of "
"songs on disc!";
return; // no idea how to recover; just do nothing
}
emit SongsMetadataLoaded(songs);
for (int i = 0; i < results.length(); ++i) {
const MusicBrainzClient::Result& new_song_info = results[i];
Song& song = disc_.tracks[i];
if (!disc_.has_titles) song.set_title(new_song_info.title_);
if (song.album().isEmpty()) song.set_album(album);
if (song.artist().isEmpty()) song.set_artist(artist);
if (song.length_nanosec() == -1)
song.set_length_nanosec(new_song_info.duration_msec_ * kNsecPerMsec);
if (song.track() < 1) song.set_track(new_song_info.track_);
if (song.year() == -1) song.set_year(new_song_info.year_);
}
disc_.has_titles = true;
emit SongsUpdated(disc_.tracks);
}
void CddaSongLoader::SetDiscTracks(const SongList& songs, bool has_titles) {
disc_.tracks = songs;
disc_.has_titles = has_titles;
emit SongsUpdated(disc_.tracks);
}

42
src/devices/cddasongloader.h
View File

@ -1,5 +1,6 @@
/* This file is part of Clementine.
Copyright 2014, David Sansome <me@davidsansome.com>
Copyright 2021, Lukas Prediger <lumip@lumip.de>
Clementine is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -42,30 +43,65 @@ class CddaSongLoader : public QObject {
~CddaSongLoader();
// Load songs.
// Signals declared below will be emitted anytime new information will be
// Signals declared below will be emitted anytime new information becomes
// available.
void LoadSongs();
bool IsActive() const;
signals:
// Emitted whenever information about tracks were updated.
// Guarantees consistency with previous updates, i.e., consumers can rely
// entirely on the updated list and do not have to merge metadata. May be
// emitted multiple times during reading the disc.
void SongsUpdated(const SongList& songs);
// The following signals are mostly for internal processing; other classes
// can get all relevant updates by just connecting to SongsUpdated. However,
// the more specialised remain available.
// Emitted when the number of tracks has been initially loaded from the disc.
// This is a specialised signal; subscribe to SongsUpdated for general updates
// information about tracks is updated.
void SongsLoaded(const SongList& songs);
// Emitted when track durations have been loaded from the disc.
// This is a specialised signal; subscribe to SongsUpdated for general updates
// information about tracks is updated.
void SongsDurationLoaded(const SongList& songs);
// Emitted when metadata has been loaded from the disc.
// This is a specialised signal; subscribe to SongsUpdated for general updates
// information about tracks is updated.
void SongsMetadataLoaded(const SongList& songs);
// Emitted when the MusicBrainz disc id has been determined.
// This is a specialised signal; subscribe to SongsUpdated for general updates
// information about tracks is updated.
void MusicBrainzDiscIdLoaded(const QString& musicbrainz_discid);
private slots:
void LoadAudioCDTags(const QString& musicbrainz_discid) const;
void AudioCDTagsLoaded(const QString& artist, const QString& album,
const MusicBrainzClient::ResultList& results);
void ProcessMusicBrainzResponse(const QString& artist, const QString& album,
const MusicBrainzClient::ResultList& results);
void SetDiscTracks(const SongList& songs, bool has_titles);
private:
QUrl GetUrlFromTrack(int track_number) const;
void LoadSongsFromCdda();
// Parse gstreamer taglist for a song
// Returns true if any tags were read, updates the Song object in songs
// accordingly, and returns the zero-based track index via the track_no
// argument.
bool ParseSongTags(SongList& songs, GstTagList* tags, gint* track_no);
struct Disc {
SongList tracks;
bool has_titles; // indicates that titles have been read and are not
// defaulted
};
QUrl url_;
GstElement* cdda_;
QFuture<void> loading_future_;
std::atomic<bool> may_load_;
Disc disc_;
};
#endif // CDDASONGLOADER_H

13
src/ripper/ripcddialog.cpp
View File

@ -343,10 +343,7 @@ void RipCDDialog::DeviceSelected(int device_index) {
loader_ = cdda_device_->loader();
Q_ASSERT(loader_);
connect(loader_, SIGNAL(SongsDurationLoaded(SongList)),
SLOT(SongsLoaded(SongList)));
connect(loader_, SIGNAL(SongsMetadataLoaded(SongList)),
SLOT(SongsLoaded(SongList)));
connect(loader_, SIGNAL(SongsUpdated(SongList)), SLOT(SongsLoaded(SongList)));
// load songs from new SongLoader
loader_->LoadSongs();
@ -434,8 +431,12 @@ void RipCDDialog::UpdateMetadataEdits() {
const Song& song = songs_.first();
ui_->albumLineEdit->setText(song.album());
ui_->artistLineEdit->setText(song.artist());
ui_->yearLineEdit->setText(QString::number(song.year()));
if (!song.artist().isEmpty())
ui_->artistLineEdit->setText(song.artist());
else
ui_->artistLineEdit->setText(song.albumartist());
ui_->yearLineEdit->setText(song.PrettyYear());
ui_->genreLineEdit->setText(song.genre());
}
void RipCDDialog::DiscChanged() { ResetDialog(); }