add play queue API & tests (#282)

Author: hyperblast

cpp/server/CMakeLists.txt

@@ -89,7 +89,9 @@ set(
     json.hpp
     log.cpp log.hpp
     parsing.cpp parsing.hpp
-    player_api.cpp player_api.hpp
+    play_queue_controller.cpp
+    play_queue_controller.hpp
+    player_api.hpp
     player_api_json.cpp player_api_json.hpp
     player_api_parsers.cpp player_api_parsers.hpp
     player_controller.cpp player_controller.hpp

cpp/server/core_types.hpp

@@ -29,7 +29,7 @@ struct Range
     int32_t offset;
     int32_t count;
 
-    int32_t endOffset()
+    int32_t endOffset() const
     {
         return offset + count;
     }

cpp/server/deadbeef/player.hpp

@@ -12,17 +12,36 @@
 
 namespace msrv::player_deadbeef {
 
-class PlayerImpl : public Player
+class ColumnsQueryImpl final : public ColumnsQuery
+{
+public:
+    explicit ColumnsQueryImpl(const std::vector<std::string>& columns)
+        : columns_(compileColumns(columns))
+    {
+    }
+
+    ~ColumnsQueryImpl() = default;
+
+    std::vector<std::string> evaluate(ddb_playlist_t* playlist, ddb_playItem_t* item)
+    {
+        return evaluateColumns(playlist, item, columns_);
+    }
+
+private:
+    std::vector<TitleFormatPtr> columns_;
+};
+
+class PlayerImpl final : public Player
 {
 public:
     static void endModifyPlaylist(ddb_playlist_t* playlist);
 
     PlayerImpl();
-    ~PlayerImpl() override;
+    ~PlayerImpl() = default;
 
     std::unique_ptr<WorkQueue> createWorkQueue() override;
 
-    PlayerStatePtr queryPlayerState(TrackQuery* activeItemQuery = nullptr) override;
+    PlayerStatePtr queryPlayerState(ColumnsQuery* activeItemQuery = nullptr) override;
 
     void playCurrent() override;
     void playItem(const PlaylistRef& playlist, int32_t itemIndex) override;
@@ -40,11 +59,10 @@ class PlayerImpl : public Player
     void seekRelative(double offsetSeconds) override;
     void setVolume(double val) override;
 
-    TrackQueryPtr createTrackQuery(
-        const std::vector<std::string>& columns) override;
+    ColumnsQueryPtr createColumnsQuery(const std::vector<std::string>& columns) override;
 
     std::vector<PlaylistInfo> getPlaylists() override;
-    PlaylistItemsResult getPlaylistItems(PlaylistQuery* query) override;
+    PlaylistItemsResult getPlaylistItems(const PlaylistRef& plref, const Range& range, ColumnsQuery* query) override;
 
     void addPlaylist(int32_t index, const std::string& title) override;
     void removePlaylist(const PlaylistRef& playlist) override;
@@ -82,10 +100,11 @@ class PlayerImpl : public Player
 
     void sortPlaylistRandom(const PlaylistRef& plref) override;
 
-    PlaylistQueryPtr createPlaylistQuery(
-        const PlaylistRef& playlist,
-        const Range& range,
-        const std::vector<std::string>& columns) override;
+    std::vector<PlayQueueItemInfo> getPlayQueue(ColumnsQuery* query = nullptr) override;
+    void addToPlayQueue(const PlaylistRef& plref, int32_t itemIndex, int32_t queueIndex) override;
+    void removeFromPlayQueue(int32_t queueIndex) override;
+    void removeFromPlayQueue(const PlaylistRef& plref, int32_t itemIndex) override;
+    void clearPlayQueue() override;
 
     boost::unique_future<ArtworkResult> fetchCurrentArtwork() override;
     boost::unique_future<ArtworkResult> fetchArtwork(const ArtworkQuery& query) override;
@@ -98,7 +117,7 @@ class PlayerImpl : public Player
     using PlaylistItemSelector = DB_playItem_t* (*)(DB_playItem_t*, int);
 
     PlaybackState getPlaybackState(ddb_playItem_t* activeItem);
-    void queryActiveItem(ActiveItemInfo* info, ddb_playItem_t* activeItem, TrackQuery* query);
+    void queryActiveItem(ActiveItemInfo* info, ddb_playItem_t* activeItem, ColumnsQuery* query);
     void queryVolume(VolumeInfo* info);
     void queryInfo(PlayerInfo* info);
     void initVersion();

cpp/server/deadbeef/player_control.cpp

@@ -7,33 +7,14 @@ namespace player_deadbeef {
 
 namespace {
 
-class TrackQueryImpl : public TrackQuery
-{
-public:
-    TrackQueryImpl(const std::vector<std::string>& columns)
-        : formatters(compileColumns(columns))
-    {
-    }
-
-    ~TrackQueryImpl() = default;
-
-    std::vector<TitleFormatPtr> formatters;
-};
-
 inline float clampVolume(float val)
 {
     return std::max(std::min(val, 0.0f), ddbApi->volume_get_min_db());
 }
 
 }
 
-std::unique_ptr<TrackQuery> PlayerImpl::createTrackQuery(
-    const std::vector<std::string>& columns)
-{
-    return std::make_unique<TrackQueryImpl>(columns);
-}
-
-std::unique_ptr<PlayerState> PlayerImpl::queryPlayerState(TrackQuery* activeItemQuery)
+std::unique_ptr<PlayerState> PlayerImpl::queryPlayerState(ColumnsQuery* activeItemQuery)
 {
     auto state = std::make_unique<PlayerState>();
 
@@ -79,7 +60,7 @@ PlaybackState PlayerImpl::getPlaybackState(ddb_playItem_t* activeItem)
     }
 }
 
-void PlayerImpl::queryActiveItem(ActiveItemInfo* info, ddb_playItem_t* activeItem, TrackQuery* query)
+void PlayerImpl::queryActiveItem(ActiveItemInfo* info, ddb_playItem_t* activeItem, ColumnsQuery* query)
 {
     int playlistIndex = ddbApi->streamer_get_current_playlist();
 
@@ -102,12 +83,13 @@ void PlayerImpl::queryActiveItem(ActiveItemInfo* info, ddb_playItem_t* activeIte
         itemDuration = ddbApi->pl_get_item_duration(activeItem);
 
         if (playlist)
+        {
             itemIndex = ddbApi->plt_get_item_idx(playlist.get(), activeItem, PL_MAIN);
+        }
 
-        if (query)
+        if (auto queryImpl = dynamic_cast<ColumnsQueryImpl*>(query))
         {
-            auto queryImpl = static_cast<TrackQueryImpl*>(query);
-            columns = evaluateColumns(playlist.get(), activeItem, queryImpl->formatters);
+            columns = queryImpl->evaluate(playlist.get(), activeItem);
         }
     }
 

cpp/server/deadbeef/player_misc.cpp

@@ -12,7 +12,10 @@ PlayerImpl::PlayerImpl()
     addOption(&stopAfterCurrentAlbumOption_);
 }
 
-PlayerImpl::~PlayerImpl() = default;
+ColumnsQueryPtr PlayerImpl::createColumnsQuery(const std::vector<std::string>& columns)
+{
+    return std::make_unique<ColumnsQueryImpl>(columns);
+}
 
 std::unique_ptr<WorkQueue> PlayerImpl::createWorkQueue()
 {
@@ -46,6 +49,88 @@ void PlayerImpl::disconnect()
     artworkFetcher_.reset();
 }
 
+std::vector<PlayQueueItemInfo> PlayerImpl::getPlayQueue(ColumnsQuery* query)
+{
+    auto queryImpl = dynamic_cast<ColumnsQueryImpl*>(query);
+
+    PlaylistLockGuard lock(playlistMutex_);
+
+    std::vector<PlayQueueItemInfo> items;
+    auto size = ddbApi->playqueue_get_count();
+
+    if (!size)
+    {
+        return items;
+    }
+
+    items.reserve(size);
+
+    for (auto i = 0; i < size; i++)
+    {
+        PlaylistItemPtr item(ddbApi->playqueue_get_item(i));
+        PlaylistPtr playlist(ddbApi->pl_get_playlist(item.get()));
+        auto playlistId = playlists_.getId(playlist.get());
+        auto playlistIndex = ddbApi->plt_get_idx(playlist.get());
+        auto itemIndex = ddbApi->plt_get_item_idx(playlist.get(), item.get(), PL_MAIN);
+
+        if (queryImpl)
+        {
+            auto columns = queryImpl->evaluate(playlist.get(), item.get());
+            items.emplace_back(playlistId, playlistIndex, itemIndex, std::move(columns));
+        }
+        else
+        {
+            items.emplace_back(playlistId, playlistIndex, itemIndex);
+        }
+    }
+
+    return items;
+}
+
+void PlayerImpl::addToPlayQueue(const PlaylistRef& plref, int32_t itemIndex, int32_t queueIndex)
+{
+    PlaylistLockGuard lock(playlistMutex_);
+
+    auto playlist = playlists_.resolve(plref);
+    auto item = resolvePlaylistItem(playlist.get(), itemIndex);
+
+    if (!item)
+        throw InvalidRequestException("itemIndex is out of range");
+
+    if (queueIndex < 0 || queueIndex >= ddbApi->playqueue_get_count())
+        ddbApi->playqueue_push(item.get());
+    else
+        ddbApi->playqueue_insert_at(queueIndex, item.get());
+}
+
+void PlayerImpl::removeFromPlayQueue(int32_t queueIndex)
+{
+    PlaylistLockGuard lock(playlistMutex_);
+
+    if (queueIndex < 0 || queueIndex >= ddbApi->playqueue_get_count())
+        throw InvalidRequestException("queueIndex is out of range");
+
+    ddbApi->playqueue_remove_nth(queueIndex);
+}
+
+void PlayerImpl::removeFromPlayQueue(const PlaylistRef& plref, int32_t itemIndex)
+{
+    PlaylistLockGuard lock(playlistMutex_);
+
+    auto playlist = playlists_.resolve(plref);
+    auto item = resolvePlaylistItem(playlist.get(), itemIndex);
+
+    if (!item)
+        throw InvalidRequestException("itemIndex is out of range");
+
+    ddbApi->playqueue_remove(item.get());
+}
+
+void PlayerImpl::clearPlayQueue()
+{
+    ddbApi->playqueue_clear();
+}
+
 boost::unique_future<ArtworkResult> PlayerImpl::fetchCurrentArtwork()
 {
     if (!artworkFetcher_)
@@ -99,12 +184,24 @@ void PlayerImpl::handleMessage(uint32_t id, uintptr_t, uint32_t p1, uint32_t)
         emitEvents(PlayerEvents::PLAYER_CHANGED);
         break;
 
+    case DB_EV_TRACKINFOCHANGED:
+        switch (p1)
+        {
+        case DDB_PLAYLIST_CHANGE_PLAYQUEUE:
+            emitEvents(PlayerEvents::PLAY_QUEUE_CHANGED);
+            break;
+        }
+        break;
+
     case DB_EV_PLAYLISTCHANGED:
         switch (p1)
         {
         case DDB_PLAYLIST_CHANGE_CONTENT:
-            // Notify player change for the case when currently played item is reordered or removed
-            emitEvents(PlayerEvents::PLAYER_CHANGED | PlayerEvents::PLAYLIST_ITEMS_CHANGED);
+            // Notify player/queue change for the case when currently played/queued item is reordered or removed
+            emitEvents(
+                PlayerEvents::PLAYER_CHANGED |
+                PlayerEvents::PLAYLIST_ITEMS_CHANGED |
+                PlayerEvents::PLAY_QUEUE_CHANGED);
             break;
 
         case DDB_PLAYLIST_CHANGE_CREATED:
@@ -114,8 +211,15 @@ void PlayerImpl::handleMessage(uint32_t id, uintptr_t, uint32_t p1, uint32_t)
 
         case DDB_PLAYLIST_CHANGE_DELETED:
         case DDB_PLAYLIST_CHANGE_POSITION:
-            // Reordering or removing playlists might change index of currently playing playlist
-            emitEvents(PlayerEvents::PLAYER_CHANGED | PlayerEvents::PLAYLIST_SET_CHANGED);
+            // Reordering or removing playlists might change playlist index of currently playing/queued item
+            emitEvents(
+                PlayerEvents::PLAYER_CHANGED |
+                PlayerEvents::PLAYLIST_SET_CHANGED |
+                PlayerEvents::PLAY_QUEUE_CHANGED);
+            break;
+
+        case DDB_PLAYLIST_CHANGE_PLAYQUEUE:
+            emitEvents(PlayerEvents::PLAY_QUEUE_CHANGED);
             break;
         }
 

cpp/server/deadbeef/player_playlists.cpp

@@ -4,21 +4,6 @@
 namespace msrv {
 namespace player_deadbeef {
 
-class PlaylistQueryImpl : public PlaylistQuery
-{
-public:
-    PlaylistQueryImpl(
-        const PlaylistRef& plrefVal,
-        const Range& rangeVal,
-        const std::vector<std::string>& columns);
-
-    ~PlaylistQueryImpl() override;
-
-    PlaylistRef plref;
-    Range range;
-    std::vector<TitleFormatPtr> formatters;
-};
-
 class AddItemsTask
 {
 public:
@@ -57,14 +42,6 @@ void PlayerImpl::endModifyPlaylist(ddb_playlist_t* playlist)
     ddbApi->sendmessage(DB_EV_PLAYLISTCHANGED, 0, DDB_PLAYLIST_CHANGE_CONTENT, 0);
 }
 
-std::unique_ptr<PlaylistQuery> PlayerImpl::createPlaylistQuery(
-    const PlaylistRef& plref,
-    const Range& range,
-    const std::vector<std::string>& columns)
-{
-    return std::make_unique<PlaylistQueryImpl>(plref, range, columns);
-}
-
 std::vector<PlaylistInfo> PlayerImpl::getPlaylists()
 {
     std::vector<PlaylistInfo> playlists;
@@ -104,19 +81,19 @@ std::vector<PlaylistInfo> PlayerImpl::getPlaylists()
     return playlists;
 }
 
-PlaylistItemsResult PlayerImpl::getPlaylistItems(PlaylistQuery* query)
+PlaylistItemsResult PlayerImpl::getPlaylistItems(const PlaylistRef& plref, const Range& range, ColumnsQuery* query)
 {
-    auto queryImpl = dynamic_cast<PlaylistQueryImpl*>(query);
+    auto queryImpl = dynamic_cast<ColumnsQueryImpl*>(query);
     if (!queryImpl)
-        throw std::logic_error("Expected PlaylistQueryImpl");
+        throw std::logic_error("ColumnsQueryImpl is required");
 
     PlaylistLockGuard lock(playlistMutex_);
 
-    PlaylistPtr playlist = playlists_.resolve(queryImpl->plref);
+    PlaylistPtr playlist = playlists_.resolve(plref);
 
     int32_t totalCount = ddbApi->plt_get_item_count(playlist.get(), PL_MAIN);
-    int32_t offset = std::min(queryImpl->range.offset, totalCount);
-    int32_t endOffset = std::min(queryImpl->range.endOffset(), totalCount);
+    int32_t offset = std::min(range.offset, totalCount);
+    int32_t endOffset = std::min(range.endOffset(), totalCount);
     int32_t count = endOffset - offset;
 
     std::vector<PlaylistItemInfo> items;
@@ -130,8 +107,7 @@ PlaylistItemsResult PlayerImpl::getPlaylistItems(PlaylistQuery* query)
         while (item && count > 0)
         {
             PlaylistItemInfo itemInfo;
-            itemInfo.columns = evaluateColumns(
-                playlist.get(), item.get(), queryImpl->formatters);
+            itemInfo.columns = queryImpl->evaluate(playlist.get(), item.get());
             items.emplace_back(std::move(itemInfo));
             item.reset(ddbApi->pl_get_next(item.get(), PL_MAIN));
             count--;
@@ -307,18 +283,6 @@ void PlayerImpl::sortPlaylistRandom(const PlaylistRef& plref)
     endModifyPlaylist(playlist.get());
 }
 
-PlaylistQueryImpl::PlaylistQueryImpl(
-    const PlaylistRef& plrefVal,
-    const Range& rangeVal,
-    const std::vector<std::string>& columns)
-    : plref(plrefVal),
-      range(rangeVal),
-      formatters(compileColumns(columns))
-{
-}
-
-PlaylistQueryImpl::~PlaylistQueryImpl() = default;
-
 AddItemsTask::AddItemsTask(
     PlaylistMapping* playlists,
     const PlaylistRef& plref,