Merge remote-tracking branch 'mixxx/2.4' into 2.5

src/library/autodj/autodjprocessor.cpp

@@ -533,6 +533,10 @@ AutoDJProcessor::AutoDJError AutoDJProcessor::toggleAutoDJ(bool enable) {
                 &DeckAttributes::rateChanged,
                 this,
                 &AutoDJProcessor::playerRateChanged);
+        connect(m_pAutoDJTableModel,
+                &PlaylistTableModel::firstTrackChanged,
+                this,
+                &AutoDJProcessor::playlistFirstTrackChanged);
 
         if (!leftDeckPlaying && !rightDeckPlaying) {
             // Both decks are stopped. Load a track into deck 1 and start it
@@ -1664,6 +1668,22 @@ void AutoDJProcessor::playerRateChanged(DeckAttributes* pAttributes) {
     calculateTransition(fromDeck, getOtherDeck(fromDeck), false);
 }
 
+void AutoDJProcessor::playlistFirstTrackChanged() {
+    if constexpr (sDebug) {
+        qDebug() << this << "playlistFirstTrackChanged";
+    }
+    if (m_eState != ADJ_DISABLED) {
+        DeckAttributes* pLeftDeck = getLeftDeck();
+        DeckAttributes* pRightDeck = getRightDeck();
+
+        if (!pLeftDeck->isPlaying()) {
+            loadNextTrackFromQueue(*pLeftDeck);
+        } else if (!pRightDeck->isPlaying()) {
+            loadNextTrackFromQueue(*pRightDeck);
+        }
+    }
+}
+
 void AutoDJProcessor::setTransitionTime(int time) {
     if constexpr (sDebug) {
         qDebug() << this << "setTransitionTime" << time;

src/library/autodj/autodjprocessor.h

@@ -219,6 +219,7 @@ class AutoDJProcessor : public QObject {
     void playerLoadingTrack(DeckAttributes* pDeck, TrackPointer pNewTrack, TrackPointer pOldTrack);
     void playerEmpty(DeckAttributes* pDeck);
     void playerRateChanged(DeckAttributes* pDeck);
+    void playlistFirstTrackChanged();
 
     void controlEnableChangeRequest(double value);
     void controlFadeNow(double value);

src/library/basesqltablemodel.h

@@ -97,7 +97,6 @@ class BaseSqlTableModel : public BaseTrackTableModel {
 
     TrackCollectionManager* const m_pTrackCollectionManager;
 
-  protected:
     QList<TrackRef> getTrackRefs(const QModelIndexList& indices) const;
 
     QSqlDatabase m_database;

src/library/basetracktablemodel.cpp

@@ -583,18 +583,6 @@ QVariant BaseTrackTableModel::data(
     return roleValue(index, rawValue(index), role);
 }
 
-QVariant BaseTrackTableModel::rawValue(
-        const QModelIndex& index) const {
-    VERIFY_OR_DEBUG_ASSERT(index.isValid()) {
-        return QVariant();
-    }
-    const auto field = mapColumn(index.column());
-    if (field == ColumnCache::COLUMN_LIBRARYTABLE_INVALID) {
-        return QVariant();
-    }
-    return rawSiblingValue(index, field);
-}
-
 QVariant BaseTrackTableModel::rawSiblingValue(
         const QModelIndex& index,
         ColumnCache::Column siblingField) const {
@@ -604,17 +592,13 @@ QVariant BaseTrackTableModel::rawSiblingValue(
     VERIFY_OR_DEBUG_ASSERT(siblingField != ColumnCache::COLUMN_LIBRARYTABLE_INVALID) {
         return QVariant();
     }
-    const auto siblingColumn = fieldIndex(siblingField);
+    const int siblingColumn = fieldIndex(siblingField);
     if (siblingColumn < 0) {
         // Unsupported or unknown column/field
         // FIXME: This should never happen but it does. But why??
         return QVariant();
     }
-    VERIFY_OR_DEBUG_ASSERT(siblingColumn != index.column()) {
-        // Prevent infinite recursion
-        return QVariant();
-    }
-    const auto siblingIndex = index.sibling(index.row(), siblingColumn);
+    const QModelIndex siblingIndex = index.sibling(index.row(), siblingColumn);
     return rawValue(siblingIndex);
 }
 

src/library/basetracktablemodel.h

@@ -169,10 +169,6 @@ class BaseTrackTableModel : public QAbstractTableModel, public TrackModel {
     virtual Qt::ItemFlags readWriteFlags(
             const QModelIndex& index) const;
 
-    /// At least one of the following functions must be overridden,
-    /// because each default implementation will call the other
-    /// function!!
-    ///
     /// Return the raw data value at the given index.
     ///
     /// Expected types by ColumnCache field (pass-through = not validated):
@@ -218,10 +214,7 @@ class BaseTrackTableModel : public QAbstractTableModel, public TrackModel {
     /// COLUMN_LIBRARYTABLE_LAST_PLAYED_AT: QDateTime
     /// COLUMN_PLAYLISTTABLE_DATETIMEADDED: QDateTime
     virtual QVariant rawValue(
-            const QModelIndex& index) const;
-    virtual QVariant rawSiblingValue(
-            const QModelIndex& index,
-            ColumnCache::Column siblingField) const;
+            const QModelIndex& index) const = 0;
 
     QVariant roleValue(
             const QModelIndex& index,
@@ -257,6 +250,10 @@ class BaseTrackTableModel : public QAbstractTableModel, public TrackModel {
             const QPixmap& pixmap);
 
   private:
+    QVariant rawSiblingValue(
+            const QModelIndex& index,
+            ColumnCache::Column siblingField) const;
+
     // Track models may reference tracks by an external id
     // TODO: TrackId should only be used for tracks from
     // the internal database.

src/library/dao/playlistdao.cpp

@@ -970,8 +970,8 @@ void PlaylistDAO::removeTracksFromPlaylists(const QList<TrackId>& trackIds, bool
                 ++it) {
             if (it.key() == trackId) {
                 const auto playlistId = it.value();
-                // keep tracks in history playlists
-                if (getHiddenType(playlistId) == PlaylistDAO::PLHT_SET_LOG) {
+                // keep hidden tracks in history playlists, remove purged tracks
+                if (!purged && getHiddenType(playlistId) == PlaylistDAO::PLHT_SET_LOG) {
                     continue;
                 }
                 removeTracksFromPlaylistByIdInner(playlistId, trackId);
@@ -981,6 +981,9 @@ void PlaylistDAO::removeTracksFromPlaylists(const QList<TrackId>& trackIds, bool
     }
     transaction.commit();
 
+    // We may now have empty history playlists. Remove them.
+    deleteAllUnlockedPlaylistsWithFewerTracks(PlaylistDAO::PLHT_SET_LOG, 1);
+
     // update the sidebar
     emit playlistContentChanged(playlistIds);
     // If this is called by TrackCollection::purgeTracks() it will call

src/library/playlisttablemodel.cpp

@@ -263,6 +263,10 @@ void PlaylistTableModel::removeTracks(const QModelIndexList& indices) {
     m_pTrackCollectionManager->internalCollection()->getPlaylistDAO().removeTracksFromPlaylist(
             m_iPlaylistId,
             std::move(trackPositions));
+
+    if (trackPositions.contains(1)) {
+        emit firstTrackChanged();
+    }
 }
 
 void PlaylistTableModel::moveTrack(const QModelIndex& sourceIndex,
@@ -288,6 +292,10 @@ void PlaylistTableModel::moveTrack(const QModelIndex& sourceIndex,
     }
 
     m_pTrackCollectionManager->internalCollection()->getPlaylistDAO().moveTrack(m_iPlaylistId, oldPosition, newPosition);
+
+    if (oldPosition == 1 || newPosition == 1) {
+        emit firstTrackChanged();
+    }
 }
 
 bool PlaylistTableModel::isLocked() {

src/library/playlisttablemodel.h

@@ -43,6 +43,9 @@ class PlaylistTableModel final : public TrackSetTableModel {
   private slots:
     void playlistsChanged(const QSet<int>& playlistIds);
 
+  signals:
+    void firstTrackChanged();
+
   private:
     void initSortColumnMapping() override;
 

src/sources/metadatasourcetaglib.cpp

@@ -115,7 +115,7 @@ MetadataSourceTagLib::importTrackMetadataAndCoverImage(
     // is read and data in subsequent tags is ignored.
 
     switch (m_fileType) {
-    case taglib::FileType::MP3: {
+    case taglib::FileType::MPEG: {
         TagLib::MPEG::File file(TAGLIB_FILENAME_FROM_QSTRING(m_fileName));
         if (!taglib::readAudioPropertiesFromFile(pTrackMetadata, file)) {
             break;
@@ -202,7 +202,7 @@ MetadataSourceTagLib::importTrackMetadataAndCoverImage(
         }
         break;
     }
-    case taglib::FileType::OGG: {
+    case taglib::FileType::OggVorbis: {
         TagLib::Ogg::Vorbis::File file(TAGLIB_FILENAME_FROM_QSTRING(m_fileName));
         if (!taglib::readAudioPropertiesFromFile(pTrackMetadata, file)) {
             break;
@@ -211,14 +211,14 @@ MetadataSourceTagLib::importTrackMetadataAndCoverImage(
         if (pTag) {
             taglib::xiph::importTrackMetadataFromTag(pTrackMetadata,
                     *pTag,
-                    taglib::FileType::OGG,
+                    taglib::FileType::OggVorbis,
                     resetMissingTagMetadata);
             taglib::xiph::importCoverImageFromTag(pCoverImage, *pTag);
             return afterImport(ImportResult::Succeeded);
         }
         break;
     }
-    case taglib::FileType::OPUS: {
+    case taglib::FileType::Opus: {
         TagLib::Ogg::Opus::File file(TAGLIB_FILENAME_FROM_QSTRING(m_fileName));
         if (!taglib::readAudioPropertiesFromFile(pTrackMetadata, file)) {
             break;
@@ -227,14 +227,14 @@ MetadataSourceTagLib::importTrackMetadataAndCoverImage(
         if (pTag) {
             taglib::xiph::importTrackMetadataFromTag(pTrackMetadata,
                     *pTag,
-                    taglib::FileType::OPUS,
+                    taglib::FileType::Opus,
                     resetMissingTagMetadata);
             taglib::xiph::importCoverImageFromTag(pCoverImage, *pTag);
             return afterImport(ImportResult::Succeeded);
         }
         break;
     }
-    case taglib::FileType::WV: {
+    case taglib::FileType::WavPack: {
         TagLib::WavPack::File file(TAGLIB_FILENAME_FROM_QSTRING(m_fileName));
         if (!taglib::readAudioPropertiesFromFile(pTrackMetadata, file)) {
             break;
@@ -478,7 +478,7 @@ class OggTagSaver : public TagSaver {
 #else
         return pFile->isOpen() &&
                 taglib::xiph::exportTrackMetadataIntoTag(
-                        pFile->tag(), trackMetadata, taglib::FileType::OGG);
+                        pFile->tag(), trackMetadata, taglib::FileType::OggVorbis);
 #endif
     }
 
@@ -507,7 +507,7 @@ class OpusTagSaver : public TagSaver {
             const TrackMetadata& trackMetadata) {
         return pFile->isOpen() &&
                 taglib::xiph::exportTrackMetadataIntoTag(
-                        pFile->tag(), trackMetadata, taglib::FileType::OPUS);
+                        pFile->tag(), trackMetadata, taglib::FileType::Opus);
     }
 
     TagLib::Ogg::Opus::File m_file;
@@ -640,7 +640,7 @@ MetadataSourceTagLib::exportTrackMetadata(
 
     std::unique_ptr<TagSaver> pTagSaver;
     switch (m_fileType) {
-    case taglib::FileType::MP3: {
+    case taglib::FileType::MPEG: {
         pTagSaver = std::make_unique<MpegTagSaver>(safelyWritableFile.fileName(), trackMetadata);
         break;
     }
@@ -652,15 +652,15 @@ MetadataSourceTagLib::exportTrackMetadata(
         pTagSaver = std::make_unique<FlacTagSaver>(safelyWritableFile.fileName(), trackMetadata);
         break;
     }
-    case taglib::FileType::OGG: {
+    case taglib::FileType::OggVorbis: {
         pTagSaver = std::make_unique<OggTagSaver>(safelyWritableFile.fileName(), trackMetadata);
         break;
     }
-    case taglib::FileType::OPUS: {
+    case taglib::FileType::Opus: {
         pTagSaver = std::make_unique<OpusTagSaver>(safelyWritableFile.fileName(), trackMetadata);
         break;
     }
-    case taglib::FileType::WV: {
+    case taglib::FileType::WavPack: {
         pTagSaver = std::make_unique<WavPackTagSaver>(safelyWritableFile.fileName(), trackMetadata);
         break;
     }

src/sources/metadatasourcetaglib.h

@@ -7,16 +7,11 @@ namespace mixxx {
 // Universal default implementation of IMetadataSource using TagLib.
 class MetadataSourceTagLib : public MetadataSource {
   public:
-    explicit MetadataSourceTagLib(
-            const QString& fileName)
-            : m_fileName(fileName),
-              m_fileType(taglib::getFileTypeFromFileName(fileName)) {
-    }
     MetadataSourceTagLib(
             const QString& fileName,
-            taglib::FileType fileType)
+            const QString& fileType)
             : m_fileName(fileName),
-              m_fileType(fileType) {
+              m_fileType(taglib::stringToEnumFileType(fileType)) {
     }
 
     std::pair<ImportResult, QDateTime> importTrackMetadataAndCoverImage(

src/sources/soundsource.cpp

@@ -83,7 +83,7 @@ QString SoundSource::getTypeFromFile(const QFileInfo& fileInfo) {
 
 SoundSource::SoundSource(const QUrl& url, const QString& type)
         : AudioSource(validateLocalFileUrl(url)),
-          MetadataSourceTagLib(getLocalFileName()),
+          MetadataSourceTagLib(getLocalFileName(), type),
           m_type(type) {
 }
 

src/sources/soundsourceffmpeg.cpp

@@ -392,12 +392,12 @@ QStringList SoundSourceProviderFFmpeg::getSupportedFileTypes() const {
                 list.append("mp4");
                 continue;
             } else if (!strcmp(pavInputFormat->name, "mov,mp4,m4a,3gp,3g2,mj2")) {
-                list.append("mov");
+                list.append("mov"); // QuickTime File Format video/quicktime
                 list.append("mp4");
                 list.append("m4a");
-                list.append("3gp");
-                list.append("3g2");
-                list.append("mj2");
+                list.append("3gp"); // 3GPP file format audio/3gpp
+                list.append("3g2"); // 3GPP2 file format audio/3gpp2
+                list.append("mj2"); // Motion JPEG 2000 video/mj2
                 continue;
             } else if (!strcmp(pavInputFormat->name, "opus") ||
                     !strcmp(pavInputFormat->name, "libopus")) {
@@ -426,30 +426,30 @@ QStringList SoundSourceProviderFFmpeg::getSupportedFileTypes() const {
                 continue;
             } else if (!strcmp(pavInputFormat->name, "wma") ||
                     !strcmp(pavInputFormat->name, "xwma")) {
-                list.append("wma");
+                list.append("wma"); // Windows Media Audio audio/x-ms-wma
                 continue;
             */
                 ///////////////////////////////////////////////////////////
                 // Untested codecs
                 ///////////////////////////////////////////////////////////
                 /*
             } else if (!strcmp(pavInputFormat->name, "ac3")) {
-                list.append("ac3");
+                list.append("ac3"); // AC-3 Compressed Audio (Dolby Digital), Revision A audio/ac3
                 continue;
             } else if (!strcmp(pavInputFormat->name, "caf")) {
-                list.append("caf");
+                list.append("caf"); // Apple Lossless
                 continue;
             } else if (!strcmp(pavInputFormat->name, "mpc")) {
-                list.append("mpc");
+                list.append("mpc"); // Musepack encoded audio audio/musepack
                 continue;
             } else if (!strcmp(pavInputFormat->name, "mpeg")) {
                 list.append("mpeg");
                 continue;
             } else if (!strcmp(pavInputFormat->name, "tak")) {
-                list.append("tak");
+                list.append("tak"); // Tom's lossless Audio Kompressor audio/x-tak
                 continue;
             } else if (!strcmp(pavInputFormat->name, "tta")) {
-                list.append("tta");
+                list.append("tta"); // True Audio, version 2
                 continue;
             */
             }

src/sources/soundsourcesndfile.cpp

@@ -16,7 +16,7 @@ const QStringList kSupportedFileTypes = {
         // ALAC/CAF has been added in version 1.0.26
         // NOTE(uklotzde, 2015-05-26): Unfortunately ALAC in M4A containers
         // is still not supported https://github.com/mixxxdj/mixxx/pull/904#issuecomment-221928362
-        QStringLiteral("caf"),
+        QStringLiteral("caf"), // Core Audio Format / Apple Lossless
         QStringLiteral("flac"),
         QStringLiteral("ogg"),
         QStringLiteral("wav"),

src/test/seratobeatgridtest.cpp

@@ -88,11 +88,11 @@ TEST_F(SeratoBeatGridTest, ParseBeatGridDataMP3) {
     parseBeatGridDataInDirectory(
             QDir(MixxxTest::getOrInitTestDir().filePath(
                     QStringLiteral("serato/data/mp3/beatgrid"))),
-            mixxx::taglib::FileType::MP3);
+            mixxx::taglib::FileType::MPEG);
 }
 
 TEST_F(SeratoBeatGridTest, ParseEmptyDataMP3) {
-    parseEmptyBeatGridData(mixxx::taglib::FileType::MP3);
+    parseEmptyBeatGridData(mixxx::taglib::FileType::MPEG);
 }
 
 TEST_F(SeratoBeatGridTest, ParseBeatGridDataMP4) {