diff --git a/src/test/trackmetadata_test.cpp b/src/test/trackmetadata_test.cpp index f0a8bee176d8..523aba4a08ea 100644 --- a/src/test/trackmetadata_test.cpp +++ b/src/test/trackmetadata_test.cpp @@ -65,27 +65,27 @@ TEST_F(TrackMetadataTest, parseArtistTitleFromFileName) { TEST_F(TrackMetadataTest, mergeImportedMetadata) { // Existing track metadata (stored in the database) without extra properties mixxx::TrackRecord oldTrackRecord; - mixxx::TrackMetadata& oldTrackMetadata = oldTrackRecord.refMetadata(); - oldTrackMetadata.setBitrate(mixxx::audio::Bitrate(100)); - oldTrackMetadata.setChannelCount(mixxx::audio::ChannelCount(1)); - oldTrackMetadata.setDuration(mixxx::Duration::fromSeconds(60)); - oldTrackMetadata.setSampleRate(mixxx::audio::SampleRate(10000)); - mixxx::TrackInfo& oldTrackInfo = oldTrackMetadata.refTrackInfo(); - oldTrackInfo.setArtist("old artist"); - oldTrackInfo.setBpm(mixxx::Bpm(100)); - oldTrackInfo.setComment("old comment"); - oldTrackInfo.setComposer("old composer"); - oldTrackInfo.setGenre("old genre"); - oldTrackInfo.setGrouping("old grouping"); - oldTrackInfo.setKey("1A"); - oldTrackInfo.setReplayGain(mixxx::ReplayGain(0.1, 1)); - oldTrackInfo.setTitle("old title"); - oldTrackInfo.setTrackNumber("1"); - oldTrackInfo.setTrackTotal("10"); - oldTrackInfo.setYear("2001-01-01"); - mixxx::AlbumInfo& oldAlbumInfo = oldTrackMetadata.refAlbumInfo(); - oldAlbumInfo.setArtist("old album artist"); - oldAlbumInfo.setTitle("old album title"); + mixxx::TrackMetadata* pOldTrackMetadata = oldTrackRecord.ptrMetadata(); + pOldTrackMetadata->setBitrate(mixxx::audio::Bitrate(100)); + pOldTrackMetadata->setChannelCount(mixxx::audio::ChannelCount(1)); + pOldTrackMetadata->setDuration(mixxx::Duration::fromSeconds(60)); + pOldTrackMetadata->setSampleRate(mixxx::audio::SampleRate(10000)); + mixxx::TrackInfo* pOldTrackInfo = pOldTrackMetadata->ptrTrackInfo(); + pOldTrackInfo->setArtist("old artist"); + pOldTrackInfo->setBpm(mixxx::Bpm(100)); + pOldTrackInfo->setComment("old comment"); + pOldTrackInfo->setComposer("old composer"); + pOldTrackInfo->setGenre("old genre"); + pOldTrackInfo->setGrouping("old grouping"); + pOldTrackInfo->setKey("1A"); + pOldTrackInfo->setReplayGain(mixxx::ReplayGain(0.1, 1)); + pOldTrackInfo->setTitle("old title"); + pOldTrackInfo->setTrackNumber("1"); + pOldTrackInfo->setTrackTotal("10"); + pOldTrackInfo->setYear("2001-01-01"); + mixxx::AlbumInfo* pOldAlbumInfo = pOldTrackMetadata->ptrAlbumInfo(); + pOldAlbumInfo->setArtist("old album artist"); + pOldAlbumInfo->setTitle("old album title"); // Imported track metadata (from file tags) with extra properties mixxx::TrackMetadata newTrackMetadata; @@ -93,135 +93,145 @@ TEST_F(TrackMetadataTest, mergeImportedMetadata) { newTrackMetadata.setChannelCount(mixxx::audio::ChannelCount(2)); newTrackMetadata.setDuration(mixxx::Duration::fromSeconds(120)); newTrackMetadata.setSampleRate(mixxx::audio::SampleRate(20000)); - mixxx::TrackInfo& newTrackInfo = newTrackMetadata.refTrackInfo(); - newTrackInfo.setArtist("new artist"); - newTrackInfo.setBpm(mixxx::Bpm(200)); - newTrackInfo.setComment("new comment"); - newTrackInfo.setComposer("new composer"); + mixxx::TrackInfo* pNewTrackInfo = newTrackMetadata.ptrTrackInfo(); + pNewTrackInfo->setArtist("new artist"); + pNewTrackInfo->setBpm(mixxx::Bpm(200)); + pNewTrackInfo->setComment("new comment"); + pNewTrackInfo->setComposer("new composer"); #if defined(__EXTRA_METADATA__) - newTrackInfo.setConductor("new conductor"); - newTrackInfo.setDiscNumber("1"); - newTrackInfo.setDiscTotal("2"); - newTrackInfo.setEncoder("encoder"); - newTrackInfo.setEncoderSettings("encoder settings"); + pNewTrackInfo->setConductor("new conductor"); + pNewTrackInfo->setDiscNumber("1"); + pNewTrackInfo->setDiscTotal("2"); + pNewTrackInfo->setEncoder("encoder"); + pNewTrackInfo->setEncoderSettings("encoder settings"); #endif // __EXTRA_METADATA__ - newTrackInfo.setGenre("new genre"); - newTrackInfo.setGrouping("new grouping"); + pNewTrackInfo->setGenre("new genre"); + pNewTrackInfo->setGrouping("new grouping"); #if defined(__EXTRA_METADATA__) - newTrackInfo.setISRC("isrc"); + pNewTrackInfo->setISRC("isrc"); #endif // __EXTRA_METADATA__ - newTrackInfo.setKey("1A"); + pNewTrackInfo->setKey("1A"); #if defined(__EXTRA_METADATA__) - newTrackInfo.setLanguage("language"); - newTrackInfo.setLyricist("lyricist"); - newTrackInfo.setMood("mood"); - newTrackInfo.setMovement("movement"); - newTrackInfo.setMusicBrainzArtistId(QUuid("11111111-1111-1111-1111-111111111111")); - newTrackInfo.setMusicBrainzRecordingId(QUuid("22222222-2222-2222-2222-222222222222")); - newTrackInfo.setMusicBrainzReleaseId(QUuid("33333333-3333-3333-3333-333333333333")); - newTrackInfo.setMusicBrainzWorkId(QUuid("44444444-4444-4444-4444-444444444444")); - newTrackInfo.setRemixer("remixer"); + pNewTrackInfo->setLanguage("language"); + pNewTrackInfo->setLyricist("lyricist"); + pNewTrackInfo->setMood("mood"); + pNewTrackInfo->setMovement("movement"); + pNewTrackInfo->setMusicBrainzArtistId(QUuid("11111111-1111-1111-1111-111111111111")); + pNewTrackInfo->setMusicBrainzRecordingId(QUuid("22222222-2222-2222-2222-222222222222")); + pNewTrackInfo->setMusicBrainzReleaseId(QUuid("33333333-3333-3333-3333-333333333333")); + pNewTrackInfo->setMusicBrainzWorkId(QUuid("44444444-4444-4444-4444-444444444444")); + pNewTrackInfo->setRemixer("remixer"); #endif // __EXTRA_METADATA__ - newTrackInfo.setReplayGain(mixxx::ReplayGain(0.2, 2)); - newTrackInfo.setTitle("new title"); - newTrackInfo.setTrackNumber("2"); - newTrackInfo.setTrackTotal("20"); + pNewTrackInfo->setReplayGain(mixxx::ReplayGain(0.2, 2)); + pNewTrackInfo->setTitle("new title"); + pNewTrackInfo->setTrackNumber("2"); + pNewTrackInfo->setTrackTotal("20"); #if defined(__EXTRA_METADATA__) newTrackInfo.setWork("work"); #endif // __EXTRA_METADATA__ - newTrackInfo.setYear("2002-02-02"); - mixxx::AlbumInfo& newAlbumInfo = newTrackMetadata.refAlbumInfo(); - newAlbumInfo.setArtist("new album artist"); + pNewTrackInfo->setYear("2002-02-02"); + mixxx::AlbumInfo* pNewAlbumInfo = newTrackMetadata.ptrAlbumInfo(); + pNewAlbumInfo->setArtist("new album artist"); #if defined(__EXTRA_METADATA__) - newAlbumInfo.setCopyright("copyright"); - newAlbumInfo.setLicense("license"); - newAlbumInfo.setMusicBrainzArtistId(QUuid("55555555-5555-5555-5555-555555555555")); - newAlbumInfo.setMusicBrainzReleaseGroupId(QUuid("66666666-6666-6666-6666-666666666666")); - newAlbumInfo.setMusicBrainzReleaseId(QUuid("77777777-7777-7777-7777-777777777777")); - newAlbumInfo.setRecordLabel("copyright"); - newAlbumInfo.setReplayGain(mixxx::ReplayGain(0.3, 3)); + pNewAlbumInfo->setCopyright("copyright"); + pNewAlbumInfo->setLicense("license"); + pNewAlbumInfo->setMusicBrainzArtistId(QUuid("55555555-5555-5555-5555-555555555555")); + pNewAlbumInfo->setMusicBrainzReleaseGroupId(QUuid("66666666-6666-6666-6666-666666666666")); + pNewAlbumInfo->setMusicBrainzReleaseId(QUuid("77777777-7777-7777-7777-777777777777")); + pNewAlbumInfo->setRecordLabel("copyright"); + pNewAlbumInfo->> setReplayGain(mixxx::ReplayGain(0.3, 3)); #endif // __EXTRA_METADATA__ - newAlbumInfo.setTitle("new album title"); + pNewAlbumInfo->setTitle("new album title"); mixxx::TrackRecord mergedTrackRecord = oldTrackRecord; ASSERT_EQ(mergedTrackRecord.getMetadata(), oldTrackRecord.getMetadata()); - ASSERT_NE(newTrackMetadata, oldTrackMetadata); + ASSERT_NE(newTrackMetadata, *pOldTrackMetadata); mergedTrackRecord.mergeImportedMetadata(newTrackMetadata); - mixxx::TrackMetadata& mergedTrackMetadata = mergedTrackRecord.refMetadata(); - EXPECT_EQ(oldTrackMetadata.getBitrate(), mergedTrackMetadata.getBitrate()); - EXPECT_EQ(oldTrackMetadata.getChannelCount(), mergedTrackMetadata.getChannelCount()); - EXPECT_EQ(oldTrackMetadata.getDuration(), mergedTrackMetadata.getDuration()); - EXPECT_EQ(oldTrackMetadata.getSampleRate(), mergedTrackMetadata.getSampleRate()); - mixxx::TrackInfo& mergedTrackInfo = mergedTrackMetadata.refTrackInfo(); - EXPECT_EQ(oldTrackInfo.getArtist(), mergedTrackInfo.getArtist()); - EXPECT_EQ(oldTrackInfo.getBpm(), mergedTrackInfo.getBpm()); - EXPECT_EQ(oldTrackInfo.getComment(), mergedTrackInfo.getComment()); - EXPECT_EQ(oldTrackInfo.getComposer(), mergedTrackInfo.getComposer()); + mixxx::TrackMetadata* pMergedTrackMetadata = mergedTrackRecord.ptrMetadata(); + EXPECT_EQ(pOldTrackMetadata->getBitrate(), pMergedTrackMetadata->getBitrate()); + EXPECT_EQ(pOldTrackMetadata->getChannelCount(), pMergedTrackMetadata->getChannelCount()); + EXPECT_EQ(pOldTrackMetadata->getDuration(), pMergedTrackMetadata->getDuration()); + EXPECT_EQ(pOldTrackMetadata->getSampleRate(), pMergedTrackMetadata->getSampleRate()); + mixxx::TrackInfo* pMergedTrackInfo = pMergedTrackMetadata->ptrTrackInfo(); + EXPECT_EQ(pOldTrackInfo->getArtist(), pMergedTrackInfo->getArtist()); + EXPECT_EQ(pOldTrackInfo->getBpm(), pMergedTrackInfo->getBpm()); + EXPECT_EQ(pOldTrackInfo->getComment(), pMergedTrackInfo->getComment()); + EXPECT_EQ(pOldTrackInfo->getComposer(), pMergedTrackInfo->getComposer()); #if defined(__EXTRA_METADATA__) - EXPECT_EQ(newTrackInfo.getConductor(), mergedTrackInfo.getConductor()); - EXPECT_EQ(newTrackInfo.getDiscNumber(), mergedTrackInfo.getDiscNumber()); - EXPECT_EQ(newTrackInfo.getDiscTotal(), mergedTrackInfo.getDiscTotal()); - EXPECT_EQ(newTrackInfo.getEncoder(), mergedTrackInfo.getEncoder()); - EXPECT_EQ(newTrackInfo.getEncoderSettings(), mergedTrackInfo.getEncoderSettings()); + EXPECT_EQ(pNewTrackInfo->getConductor(), pMergedTrackInfo->getConductor()); + EXPECT_EQ(pNewTrackInfo->getDiscNumber(), pMergedTrackInfo->getDiscNumber()); + EXPECT_EQ(pNewTrackInfo->getDiscTotal(), pMergedTrackInfo->getDiscTotal()); + EXPECT_EQ(pNewTrackInfo->getEncoder(), pMergedTrackInfo->getEncoder()); + EXPECT_EQ(pNewTrackInfo->getEncoderSettings(), pMergedTrackInfo->getEncoderSettings()); #endif // __EXTRA_METADATA__ - EXPECT_EQ(oldTrackInfo.getGenre(), mergedTrackInfo.getGenre()); - EXPECT_EQ(oldTrackInfo.getGrouping(), mergedTrackInfo.getGrouping()); + EXPECT_EQ(pOldTrackInfo->getGenre(), pMergedTrackInfo->getGenre()); + EXPECT_EQ(pOldTrackInfo->getGrouping(), pMergedTrackInfo->getGrouping()); #if defined(__EXTRA_METADATA__) - EXPECT_EQ(newTrackInfo.getISRC(), mergedTrackInfo.getISRC()); + EXPECT_EQ(pNewTrackInfo->getISRC(), pMergedTrackInfo->getISRC()); #endif // __EXTRA_METADATA__ - EXPECT_EQ(oldTrackInfo.getKey(), mergedTrackInfo.getKey()); + EXPECT_EQ(pOldTrackInfo->getKey(), pMergedTrackInfo->getKey()); #if defined(__EXTRA_METADATA__) - EXPECT_EQ(newTrackInfo.getLanguage(), mergedTrackInfo.getLanguage()); - EXPECT_EQ(newTrackInfo.getLyricist(), mergedTrackInfo.getLyricist()); - EXPECT_EQ(newTrackInfo.getMood(), mergedTrackInfo.getMood()); - EXPECT_EQ(newTrackInfo.getMovement(), mergedTrackInfo.getMovement()); - EXPECT_EQ(newTrackInfo.getMusicBrainzArtistId(), mergedTrackInfo.getMusicBrainzArtistId()); - EXPECT_EQ(newTrackInfo.getMusicBrainzRecordingId(), mergedTrackInfo.getMusicBrainzRecordingId()); - EXPECT_EQ(newTrackInfo.getMusicBrainzReleaseId(), mergedTrackInfo.getMusicBrainzReleaseId()); - EXPECT_EQ(newTrackInfo.getMusicBrainzWorkId(), mergedTrackInfo.getMusicBrainzWorkId()); - EXPECT_EQ(newTrackInfo.getRemixer(), mergedTrackInfo.getRemixer()); + EXPECT_EQ(pNewTrackInfo->getLanguage(), pMergedTrackInfo->getLanguage()); + EXPECT_EQ(pNewTrackInfo->getLyricist(), pMergedTrackInfo->getLyricist()); + EXPECT_EQ(pNewTrackInfo->getMood(), pMergedTrackInfo->getMood()); + EXPECT_EQ(pNewTrackInfo->getMovement(), pMergedTrackInfo->getMovement()); + EXPECT_EQ(pNewTrackInfo->getMusicBrainzArtistId(), pMergedTrackInfo->getMusicBrainzArtistId()); + EXPECT_EQ(pNewTrackInfo->getMusicBrainzRecordingId(), + pMergedTrackInfo->getMusicBrainzRecordingId()); + EXPECT_EQ(pNewTrackInfo->getMusicBrainzReleaseId(), + pMergedTrackInfo->getMusicBrainzReleaseId()); + EXPECT_EQ(pNewTrackInfo->getMusicBrainzWorkId(), + pMergedTrackInfo->getMusicBrainzWorkId()); + EXPECT_EQ(pNewTrackInfo->getRemixer(), pMergedTrackInfo->getRemixer()); #endif // __EXTRA_METADATA__ - EXPECT_EQ(oldTrackInfo.getReplayGain(), mergedTrackInfo.getReplayGain()); - EXPECT_EQ(oldTrackInfo.getTitle(), mergedTrackInfo.getTitle()); - EXPECT_EQ(oldTrackInfo.getTrackNumber(), mergedTrackInfo.getTrackNumber()); - EXPECT_EQ(oldTrackInfo.getTrackTotal(), mergedTrackInfo.getTrackTotal()); + EXPECT_EQ( + pOldTrackInfo->getReplayGain(), pMergedTrackInfo->getReplayGain()); + EXPECT_EQ(pOldTrackInfo->getTitle(), pMergedTrackInfo->getTitle()); + EXPECT_EQ(pOldTrackInfo->getTrackNumber(), + pMergedTrackInfo->getTrackNumber()); + EXPECT_EQ( + pOldTrackInfo->getTrackTotal(), pMergedTrackInfo->getTrackTotal()); #if defined(__EXTRA_METADATA__) - EXPECT_EQ(newTrackInfo.getWork(), mergedTrackInfo.getWork()); + EXPECT_EQ(pNewTrackInfo.getWork(), pMergedTrackInfo->getWork()); #endif // __EXTRA_METADATA__ - EXPECT_EQ(oldTrackInfo.getYear(), mergedTrackInfo.getYear()); - mixxx::AlbumInfo& mergedAlbumInfo = mergedTrackMetadata.refAlbumInfo(); - EXPECT_EQ(oldAlbumInfo.getArtist(), mergedAlbumInfo.getArtist()); + EXPECT_EQ(pOldTrackInfo->getYear(), pMergedTrackInfo->getYear()); + mixxx::AlbumInfo* pMergedAlbumInfo = + pMergedTrackMetadata->ptrAlbumInfo(); + EXPECT_EQ(pOldAlbumInfo->getArtist(), pMergedAlbumInfo->getArtist()); #if defined(__EXTRA_METADATA__) - EXPECT_EQ(newAlbumInfo.getCopyright(), mergedAlbumInfo.getCopyright()); - EXPECT_EQ(newAlbumInfo.getLicense(), mergedAlbumInfo.getLicense()); - EXPECT_EQ(newAlbumInfo.getMusicBrainzArtistId(), mergedAlbumInfo.getMusicBrainzArtistId()); - EXPECT_EQ(newAlbumInfo.getMusicBrainzReleaseGroupId(), mergedAlbumInfo.getMusicBrainzReleaseGroupId()); - EXPECT_EQ(newAlbumInfo.getMusicBrainzReleaseId(), mergedAlbumInfo.getMusicBrainzReleaseId()); - EXPECT_EQ(newAlbumInfo.getRecordLabel(), mergedAlbumInfo.getRecordLabel()); - EXPECT_EQ(newAlbumInfo.getReplayGain(), mergedAlbumInfo.getReplayGain()); + EXPECT_EQ(pNewAlbumInfo->getCopyright(), pMergedAlbumInfo->getCopyright()); + EXPECT_EQ(pNewAlbumInfo->getLicense(), pMergedAlbumInfo->getLicense()); + EXPECT_EQ(pNewAlbumInfo->getMusicBrainzArtistId(), + pMergedAlbumInfo->getMusicBrainzArtistId()); + EXPECT_EQ(pNewAlbumInfo->getMusicBrainzReleaseGroupId(), + pMergedAlbumInfo->getMusicBrainzReleaseGroupId()); + EXPECT_EQ(pNewAlbumInfo->getMusicBrainzReleaseId(), + pMergedAlbumInfo->getMusicBrainzReleaseId()); + EXPECT_EQ(pNewAlbumInfo->getRecordLabel(), pMergedAlbumInfo->getRecordLabel()); + EXPECT_EQ(pNewAlbumInfo->getReplayGain(), pMergedAlbumInfo->getReplayGain()); #endif // __EXTRA_METADATA__ - EXPECT_EQ(oldAlbumInfo.getTitle(), mergedAlbumInfo.getTitle()); + EXPECT_EQ(pOldAlbumInfo->getTitle(), pMergedAlbumInfo->getTitle()); // Check that all existing properties are preserved, even if empty or missing - mergedTrackInfo.setArtist(""); - mergedTrackInfo.setTitle(QString()); - mergedAlbumInfo.setArtist(""); - mergedAlbumInfo.setTitle(QString()); + pMergedTrackInfo->setArtist(""); + pMergedTrackInfo->setTitle(QString()); + pMergedAlbumInfo->setArtist(""); + pMergedAlbumInfo->setTitle(QString()); mergedTrackRecord.mergeImportedMetadata(newTrackMetadata); - EXPECT_EQ(QString(""), mergedTrackInfo.getArtist()); - EXPECT_EQ(QString(), mergedTrackInfo.getTitle()); - EXPECT_EQ(QString(""), mergedAlbumInfo.getArtist()); - EXPECT_EQ(QString(), mergedAlbumInfo.getTitle()); + EXPECT_EQ(QString(""), pMergedTrackInfo->getArtist()); + EXPECT_EQ(QString(), pMergedTrackInfo->getTitle()); + EXPECT_EQ(QString(""), pMergedAlbumInfo->getArtist()); + EXPECT_EQ(QString(), pMergedAlbumInfo->getTitle()); // Check that the placeholder for track total is replaced with the actual property - ASSERT_NE(mixxx::TrackRecord::kTrackTotalPlaceholder, newTrackInfo.getTrackTotal()); - mergedTrackInfo.setTrackTotal(mixxx::TrackRecord::kTrackTotalPlaceholder); + ASSERT_NE(mixxx::TrackRecord::kTrackTotalPlaceholder, pNewTrackInfo->getTrackTotal()); + pMergedTrackInfo->setTrackTotal(mixxx::TrackRecord::kTrackTotalPlaceholder); mergedTrackRecord.mergeImportedMetadata(newTrackMetadata); - EXPECT_EQ(newTrackInfo.getTrackTotal(), mergedTrackInfo.getTrackTotal()); + EXPECT_EQ(pNewTrackInfo->getTrackTotal(), pMergedTrackInfo->getTrackTotal()); // ...but if track total is missing entirely it should be preserved - ASSERT_NE(QString(), newTrackInfo.getTrackTotal()); - mergedTrackInfo.setTrackTotal(QString()); + ASSERT_NE(QString(), pNewTrackInfo->getTrackTotal()); + pMergedTrackInfo->setTrackTotal(QString()); mergedTrackRecord.mergeImportedMetadata(newTrackMetadata); - EXPECT_EQ(QString(), mergedTrackInfo.getTrackTotal()); + EXPECT_EQ(QString(), pMergedTrackInfo->getTrackTotal()); } diff --git a/src/track/track.cpp b/src/track/track.cpp index a9413bdf9ff0..057a713755e0 100644 --- a/src/track/track.cpp +++ b/src/track/track.cpp @@ -146,7 +146,7 @@ void Track::importMetadata( // stamps if file tags need to be re-imported. if (!metadataSynchronized.isNull()) { modified |= compareAndSet( - &m_record.refMetadataSynchronized(), + m_record.ptrMetadataSynchronized(), true); } bool modifiedReplayGain = false; @@ -226,7 +226,7 @@ mixxx::ReplayGain Track::getReplayGain() const { void Track::setReplayGain(const mixxx::ReplayGain& replayGain) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refReplayGain(), replayGain)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrReplayGain(), replayGain)) { markDirtyAndUnlock(&lock); emit ReplayGainUpdated(replayGain); } @@ -337,7 +337,7 @@ void Track::slotBeatsUpdated() { void Track::setMetadataSynchronized(bool metadataSynchronized) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refMetadataSynchronized(), metadataSynchronized)) { + if (compareAndSet(m_record.ptrMetadataSynchronized(), metadataSynchronized)) { markDirtyAndUnlock(&lock); } } @@ -379,8 +379,8 @@ void Track::setDuration(mixxx::Duration duration) { return; } if (compareAndSet( - &m_record.refMetadata().refDuration(), - duration)) { + m_record.refMetadata().ptrDuration(), + duration)) { markDirtyAndUnlock(&lock); } } @@ -420,7 +420,7 @@ QString Track::getTitle() const { void Track::setTitle(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refTitle(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrTitle(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -433,7 +433,7 @@ QString Track::getArtist() const { void Track::setArtist(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refArtist(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrArtist(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -446,7 +446,7 @@ QString Track::getAlbum() const { void Track::setAlbum(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refAlbumInfo().refTitle(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refAlbumInfo().ptrTitle(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -459,7 +459,7 @@ QString Track::getAlbumArtist() const { void Track::setAlbumArtist(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refAlbumInfo().refArtist(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refAlbumInfo().ptrArtist(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -472,7 +472,7 @@ QString Track::getYear() const { void Track::setYear(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refYear(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrYear(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -485,7 +485,7 @@ QString Track::getGenre() const { void Track::setGenre(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refGenre(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrGenre(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -498,7 +498,7 @@ QString Track::getComposer() const { void Track::setComposer(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refComposer(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrComposer(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -511,7 +511,7 @@ QString Track::getGrouping() const { void Track::setGrouping(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refGrouping(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrGrouping(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -529,7 +529,7 @@ QString Track::getTrackTotal() const { void Track::setTrackNumber(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refTrackNumber(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrTrackNumber(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -537,7 +537,7 @@ void Track::setTrackNumber(const QString& s) { void Track::setTrackTotal(const QString& s) { QMutexLocker lock(&m_qMutex); QString trimmed(s.trimmed()); - if (compareAndSet(&m_record.refMetadata().refTrackInfo().refTrackTotal(), trimmed)) { + if (compareAndSet(m_record.refMetadata().refTrackInfo().ptrTrackTotal(), trimmed)) { markDirtyAndUnlock(&lock); } } @@ -549,7 +549,7 @@ PlayCounter Track::getPlayCounter() const { void Track::setPlayCounter(const PlayCounter& playCounter) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refPlayCounter(), playCounter)) { + if (compareAndSet(m_record.ptrPlayCounter(), playCounter)) { markDirtyAndUnlock(&lock); } } @@ -558,7 +558,7 @@ void Track::updatePlayCounter(bool bPlayed) { QMutexLocker lock(&m_qMutex); PlayCounter playCounter(m_record.getPlayCounter()); playCounter.setPlayedAndUpdateTimesPlayed(bPlayed); - if (compareAndSet(&m_record.refPlayCounter(), playCounter)) { + if (compareAndSet(m_record.ptrPlayCounter(), playCounter)) { markDirtyAndUnlock(&lock); } } @@ -570,7 +570,7 @@ mixxx::RgbColor::optional_t Track::getColor() const { void Track::setColor(mixxx::RgbColor::optional_t color) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refColor(), color)) { + if (compareAndSet(m_record.ptrColor(), color)) { markDirtyAndUnlock(&lock); } } @@ -594,7 +594,7 @@ QString Track::getType() const { void Track::setType(const QString& sType) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refFileType(), sType)) { + if (compareAndSet(m_record.ptrFileType(), sType)) { markDirtyAndUnlock(&lock); } } @@ -632,8 +632,8 @@ void Track::setBitrate(int iBitrate) { return; } if (compareAndSet( - &m_record.refMetadata().refBitrate(), - bitrate)) { + m_record.refMetadata().ptrBitrate(), + bitrate)) { markDirtyAndUnlock(&lock); } } @@ -664,7 +664,7 @@ void Track::resetId() { void Track::setURL(const QString& url) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refUrl(), url)) { + if (compareAndSet(m_record.ptrUrl(), url)) { markDirtyAndUnlock(&lock); } } @@ -695,7 +695,7 @@ void Track::setWaveformSummary(ConstWaveformPointer pWaveform) { void Track::setCuePoint(CuePosition cue) { QMutexLocker lock(&m_qMutex); - if (!compareAndSet(&m_record.refCuePoint(), cue)) { + if (!compareAndSet(m_record.ptrCuePoint(), cue)) { // Nothing changed. return; } @@ -792,7 +792,7 @@ void Track::removeCuesOfType(mixxx::CueType type) { dirty = true; } } - if (compareAndSet(&m_record.refCuePoint(), CuePosition())) { + if (compareAndSet(m_record.ptrCuePoint(), CuePosition())) { dirty = true; } if (dirty) { @@ -954,7 +954,7 @@ int Track::getRating() const { void Track::setRating (int rating) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refRating(), rating)) { + if (compareAndSet(m_record.ptrRating(), rating)) { markDirtyAndUnlock(&lock); } } @@ -1012,7 +1012,7 @@ void Track::setKeyText(const QString& keyText, void Track::setBpmLocked(bool bpmLocked) { QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refBpmLocked(), bpmLocked)) { + if (compareAndSet(m_record.ptrBpmLocked(), bpmLocked)) { markDirtyAndUnlock(&lock); } } @@ -1026,7 +1026,7 @@ void Track::setCoverInfo(const CoverInfoRelative& coverInfo) { DEBUG_ASSERT((coverInfo.type != CoverInfo::METADATA) || coverInfo.coverLocation.isEmpty()); DEBUG_ASSERT((coverInfo.source != CoverInfo::UNKNOWN) || (coverInfo.type == CoverInfo::NONE)); QMutexLocker lock(&m_qMutex); - if (compareAndSet(&m_record.refCoverInfo(), coverInfo)) { + if (compareAndSet(m_record.ptrCoverInfo(), coverInfo)) { markDirtyAndUnlock(&lock); emit coverArtUpdated(); } @@ -1044,8 +1044,8 @@ bool Track::refreshCoverImageHash( return false; } if (!compareAndSet( - &m_record.refCoverInfo(), - static_cast(coverInfo))) { + m_record.ptrCoverInfo(), + static_cast(coverInfo))) { return false; } kLogger.info() @@ -1202,22 +1202,22 @@ void Track::setAudioProperties( DEBUG_ASSERT(!m_streamInfo); bool dirty = false; if (compareAndSet( - &m_record.refMetadata().refChannelCount(), + m_record.refMetadata().ptrChannelCount(), channelCount)) { dirty = true; } if (compareAndSet( - &m_record.refMetadata().refSampleRate(), + m_record.refMetadata().ptrSampleRate(), sampleRate)) { dirty = true; } if (compareAndSet( - &m_record.refMetadata().refBitrate(), + m_record.refMetadata().ptrBitrate(), bitrate)) { dirty = true; } if (compareAndSet( - &m_record.refMetadata().refDuration(), + m_record.refMetadata().ptrDuration(), duration)) { dirty = true; } diff --git a/src/track/trackinfo.h b/src/track/trackinfo.h index 9f784a181bd0..f51de9375fa6 100644 --- a/src/track/trackinfo.h +++ b/src/track/trackinfo.h @@ -72,8 +72,8 @@ class TrackInfo final { // Adjusts floating-point properties to match their string representation // in file tags to account for rounding errors. void normalizeBeforeExport() { - refBpm().normalizeBeforeExport(); - refReplayGain().normalizeBeforeExport(); + m_bpm.normalizeBeforeExport(); + m_replayGain.normalizeBeforeExport(); } bool compareEq( diff --git a/src/track/trackmetadata.cpp b/src/track/trackmetadata.cpp index 8085e260b557..fc82f30160cf 100644 --- a/src/track/trackmetadata.cpp +++ b/src/track/trackmetadata.cpp @@ -139,8 +139,8 @@ QString TrackMetadata::reformatYear(QString year) { } void TrackMetadata::normalizeBeforeExport() { - refAlbumInfo().normalizeBeforeExport(); - refTrackInfo().normalizeBeforeExport(); + m_albumInfo.normalizeBeforeExport(); + m_trackInfo.normalizeBeforeExport(); } bool TrackMetadata::anyFileTagsModified( diff --git a/src/track/trackrecord.cpp b/src/track/trackrecord.cpp index 2cb6e421e58b..aa4c3da61234 100644 --- a/src/track/trackrecord.cpp +++ b/src/track/trackrecord.cpp @@ -92,16 +92,16 @@ void copyIfNotEmpty( void TrackRecord::mergeImportedMetadata( const TrackMetadata& importedFromFile) { - TrackInfo& mergedTrackInfo = refMetadata().refTrackInfo(); + TrackInfo* pMergedTrackInfo = m_metadata.ptrTrackInfo(); const TrackInfo& importedTrackInfo = importedFromFile.getTrackInfo(); - if (mergedTrackInfo.getTrackTotal() == kTrackTotalPlaceholder) { - mergedTrackInfo.setTrackTotal(importedTrackInfo.getTrackTotal()); + if (pMergedTrackInfo->getTrackTotal() == kTrackTotalPlaceholder) { + pMergedTrackInfo->setTrackTotal(importedTrackInfo.getTrackTotal()); // Also set the track number if it is still empty due // to insufficient parsing capabilities of Mixxx in // previous versions. - if (mergedTrackInfo.getTrackNumber().isEmpty() && + if (pMergedTrackInfo->getTrackNumber().isEmpty() && !importedTrackInfo.getTrackNumber().isEmpty()) { - mergedTrackInfo.setTrackNumber(importedTrackInfo.getTrackNumber()); + pMergedTrackInfo->setTrackNumber(importedTrackInfo.getTrackNumber()); } } #if defined(__EXTRA_METADATA__)