merge librespot:dev

Author: tsanona

CHANGELOG.md

@@ -7,12 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- [connect] Add method `add_to_queue` to `Spirc` to add tracks, episodes, albums and playlists to the queue
+- [playback] Add `SetQueue` player event, emitting when the queue changes (context loaded, track added to queue, or queue set via Spotify Connect). Gated behind `ConnectConfig::emit_set_queue_events`
+
 ### Changed
 
 - [core] Made `SpotifyId::to_base62`, `SpotifyId::to_base16`, `FileId::to_base16`, `SpotifyUri::to_id`, `SpotifyUri::to_uri` infallible (breaking)
 
 ### Fixed
 
+- [audio] Fixed integer overflow in throughput calculation
 - [main] Fixed `--volume-ctrl fixed` not disabling volume control
 - [core] Fix default permissions on credentials file and warn user if file is world readable
 - [core] Try all resolved addresses for the dealer connection instead of failing after the first one.

Cargo.lock

@@ -120,8 +120,8 @@ async fn receive_data(
     if measure_throughput {
         let duration = Instant::now().duration_since(request_time).as_millis();
         if actual_length > 0 && duration > 0 {
-            let throughput = ONE_SECOND.as_millis() as usize * actual_length / duration as usize;
-            file_data_tx.send(ReceivedData::Throughput(throughput))?;
+            let throughput = ONE_SECOND.as_millis() * actual_length as u128 / duration;
+            file_data_tx.send(ReceivedData::Throughput(throughput as usize))?;
         }
     }
 

audio/src/fetch/receive.rs

@@ -14,12 +14,13 @@ use crate::{
     model::{LoadRequest, PlayingTrack, SpircPlayStatus},
     playback::{
         mixer::Mixer,
-        player::{Player, PlayerEvent, PlayerEventChannel},
+        player::{Player, PlayerEvent, PlayerEventChannel, QueueTrack},
     },
     protocol::{
         connect::{Cluster, ClusterUpdate, LogoutCommand, SetVolumeCommand},
         context::Context,
         explicit_content_pubsub::UserAttributesUpdate,
+        player::ProvidedTrack,
         playlist4_external::PlaylistModificationInfo,
         social_connect_v2::SessionUpdate,
         transfer_state::TransferState,
@@ -94,6 +95,8 @@ struct SpircTask {
 
     context_resolver: ContextResolver,
 
+    emit_set_queue_events: bool,
+
     shutdown: bool,
     session: Session,
 
@@ -132,6 +135,7 @@ enum SpircCommand {
     Activate,
     Transfer(Option<TransferRequest>),
     Load(LoadRequest),
+    AddToQueue(SpotifyUri),
 }
 
 const CONTEXT_FETCH_THRESHOLD: usize = 2;
@@ -171,6 +175,7 @@ impl Spirc {
         let spirc_id = SPIRC_COUNTER.fetch_add(1, Ordering::AcqRel);
         debug!("new Spirc[{spirc_id}]");
 
+        let emit_set_queue_events = config.emit_set_queue_events;
         let connect_state = ConnectState::new(config, &session);
 
         let connection_id_update = session
@@ -247,6 +252,8 @@ impl Spirc {
 
             context_resolver: ContextResolver::new(session.clone()),
 
+            emit_set_queue_events,
+
             shutdown: false,
             session,
 
@@ -388,6 +395,24 @@ impl Spirc {
         Ok(self.commands.send(SpircCommand::Load(command))?)
     }
 
+    /// Adds a track, episode, album or playlist to the queue.
+    ///
+    /// Does nothing if we are not the active device.
+    ///
+    /// For albums and playlists, all tracks/episodes are resolved and added to the queue.
+    pub fn add_to_queue(&self, uri: SpotifyUri) -> Result<(), Error> {
+        if !matches!(
+            uri,
+            SpotifyUri::Track { .. }
+                | SpotifyUri::Episode { .. }
+                | SpotifyUri::Album { .. }
+                | SpotifyUri::Playlist { .. }
+        ) {
+            return Err(Error::invalid_argument("uri"));
+        }
+        Ok(self.commands.send(SpircCommand::AddToQueue(uri))?)
+    }
+
     /// Disconnects the current device and pauses the playback according the value.
     ///
     /// Does nothing if we are not the active device.
@@ -616,10 +641,52 @@ impl SpircTask {
             false
         };
 
+        // Fire set queue event if context was successfully loaded
+        if update_state {
+            self.emit_set_queue_event();
+        }
+
         self.context_resolver.remove_used_and_invalid();
         update_state
     }
 
+    /// Emit set queue event via PlayerEvent
+    fn emit_set_queue_event(&self) {
+        if !self.emit_set_queue_events {
+            return;
+        }
+
+        let state_player = self.connect_state.player();
+
+        let current_track = state_player.track.as_ref().map(|t| QueueTrack {
+            uri: t.uri.clone(),
+            provider: t.provider.clone(),
+        });
+
+        let next_tracks: Vec<_> = state_player
+            .next_tracks
+            .iter()
+            .map(|t| QueueTrack {
+                uri: t.uri.clone(),
+                provider: t.provider.clone(),
+            })
+            .collect();
+
+        let prev_tracks: Vec<_> = state_player
+            .prev_tracks
+            .iter()
+            .map(|t| QueueTrack {
+                uri: t.uri.clone(),
+                provider: t.provider.clone(),
+            })
+            .collect();
+
+        let context_uri = self.connect_state.context_uri().clone();
+
+        self.player
+            .emit_set_queue_event(context_uri, current_track, next_tracks, prev_tracks);
+    }
+
     // todo: is the time_delta still necessary?
     fn now_ms(&self) -> i64 {
         let dur = SystemTime::now()
@@ -679,6 +746,7 @@ impl SpircTask {
             SpircCommand::SetPosition(position) => self.handle_seek(position),
             SpircCommand::SetVolume(volume) => self.set_volume(volume),
             SpircCommand::Load(command) => self.handle_load(command, None, None).await?,
+            SpircCommand::AddToQueue(uri) => self.handle_add_to_queue(uri).await,
         };
 
         self.notify().await
@@ -1062,8 +1130,14 @@ impl SpircTask {
                 self.handle_repeat_context(repeat_context.value)?
             }
             SetRepeatingTrack(repeat_track) => self.handle_repeat_track(repeat_track.value),
-            AddToQueue(add_to_queue) => self.connect_state.add_to_queue(add_to_queue.track, true),
-            SetQueue(set_queue) => self.connect_state.handle_set_queue(set_queue),
+            AddToQueue(add_to_queue) => {
+                self.connect_state.add_to_queue(add_to_queue.track, true);
+                self.emit_set_queue_event();
+            }
+            SetQueue(set_queue) => {
+                self.connect_state.handle_set_queue(set_queue);
+                self.emit_set_queue_event();
+            }
             SetOptions(set_options) => {
                 if let Some(repeat_context) = set_options.repeating_context {
                     self.handle_repeat_context(repeat_context)?
@@ -1433,6 +1507,8 @@ impl SpircTask {
             .connect_state
             .update_context(ctx, ContextType::Default)?;
 
+        self.emit_set_queue_event();
+
         Ok(())
     }
 
@@ -1545,6 +1621,36 @@ impl SpircTask {
         self.connect_state.set_repeat_track(repeat);
     }
 
+    async fn handle_add_to_queue(&mut self, uri: SpotifyUri) {
+        let track_uris: Vec<String> = match uri {
+            SpotifyUri::Track { .. } | SpotifyUri::Episode { .. } => vec![uri.to_uri()],
+            SpotifyUri::Album { .. } | SpotifyUri::Playlist { .. } => {
+                match self.session.spclient().get_context(&uri.to_uri()).await {
+                    Ok(context) => context
+                        .pages
+                        .iter()
+                        .flat_map(|page| page.tracks.iter())
+                        .filter_map(|track| track.uri.clone())
+                        .collect(),
+                    Err(e) => {
+                        error!("failed to resolve context for {}: {e}", uri.item_type());
+                        return;
+                    }
+                }
+            }
+            _ => return,
+        };
+
+        for track_uri in track_uris {
+            let track = ProvidedTrack {
+                uri: track_uri.clone(),
+                ..Default::default()
+            };
+            self.connect_state.add_to_queue(track, true);
+        }
+        self.emit_set_queue_event();
+    }
+
     fn handle_preload_next_track(&mut self) {
         // Requests the player thread to preload the next track
         match self.play_status {

connect/src/spirc.rs

@@ -90,6 +90,8 @@ pub struct ConnectConfig {
     pub disable_volume: bool,
     /// Number of incremental steps (default: 64)
     pub volume_steps: u16,
+    /// Emit `SetQueue` player events when the queue changes (default: false)
+    pub emit_set_queue_events: bool,
 }
 
 impl Default for ConnectConfig {
@@ -101,6 +103,7 @@ impl Default for ConnectConfig {
             initial_volume: ConnectConfig::DEFAULT_INITIAL_VOLUME,
             disable_volume: false,
             volume_steps: ConnectConfig::DEFAULT_VOLUME_STEPS,
+            emit_set_queue_events: false,
         }
     }
 }

connect/src/state.rs

@@ -113,9 +113,11 @@ clap = { version = "4.5.54", default-features = false }
 [build-dependencies]
 rand = { version = "0.9", default-features = false, features = ["thread_rng"] }
 rand_distr = "0.5"
-vergen-gitcl = { version = "1.0", default-features = false, features = [
+vergen-gitcl = { version = "1.0.8", default-features = false, features = [
     "build",
 ] }
+# fix for https://github.com/rustyhorde/vergen/issues/478#issuecomment-3769340357
+vergen = "=9.0.6"
 
 [dev-dependencies]
 tokio = { version = "1", features = ["macros"] }

core/Cargo.toml

@@ -138,6 +138,19 @@ enum PlayerCommand {
         track: bool,
     },
     EmitAutoPlayChangedEvent(bool),
+    EmitSetQueueEvent {
+        context_uri: String,
+        current_track: Option<QueueTrack>,
+        next_tracks: Vec<QueueTrack>,
+        prev_tracks: Vec<QueueTrack>,
+    },
+}
+
+/// Represents a track in the queue with its URI and provider.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct QueueTrack {
+    pub uri: String,
+    pub provider: String,
 }
 
 #[derive(Debug, Clone)]
@@ -248,6 +261,13 @@ pub enum PlayerEvent {
     FilterExplicitContentChanged {
         filter: bool,
     },
+    /// Fired when the queue is set or context is loaded with its track list.
+    SetQueue {
+        context_uri: String,
+        current_track: Option<QueueTrack>,
+        next_tracks: Vec<QueueTrack>,
+        prev_tracks: Vec<QueueTrack>,
+    },
 }
 
 impl PlayerEvent {
@@ -647,6 +667,21 @@ impl Player {
     pub fn emit_auto_play_changed_event(&self, auto_play: bool) {
         self.command(PlayerCommand::EmitAutoPlayChangedEvent(auto_play));
     }
+
+    pub fn emit_set_queue_event(
+        &self,
+        context_uri: String,
+        current_track: Option<QueueTrack>,
+        next_tracks: Vec<QueueTrack>,
+        prev_tracks: Vec<QueueTrack>,
+    ) {
+        self.command(PlayerCommand::EmitSetQueueEvent {
+            context_uri,
+            current_track,
+            next_tracks,
+            prev_tracks,
+        });
+    }
 }
 
 impl Drop for Player {
@@ -2335,6 +2370,18 @@ impl PlayerInternal {
                 self.auto_normalise_as_album = setting
             }
 
+            PlayerCommand::EmitSetQueueEvent {
+                context_uri,
+                current_track,
+                next_tracks,
+                prev_tracks,
+            } => self.send_event(PlayerEvent::SetQueue {
+                context_uri,
+                current_track,
+                next_tracks,
+                prev_tracks,
+            }),
+
             PlayerCommand::EmitFilterExplicitContentChangedEvent(filter) => {
                 self.send_event(PlayerEvent::FilterExplicitContentChanged { filter });
 
@@ -2536,6 +2583,17 @@ impl fmt::Debug for PlayerCommand {
                 .debug_tuple("EmitAutoPlayChangedEvent")
                 .field(&auto_play)
                 .finish(),
+            PlayerCommand::EmitSetQueueEvent {
+                context_uri,
+                next_tracks,
+                prev_tracks,
+                ..
+            } => f
+                .debug_tuple("EmitSetQueueEvent")
+                .field(&context_uri)
+                .field(&next_tracks.len())
+                .field(&prev_tracks.len())
+                .finish(),
         }
     }
 }