Rust音频播放库librespot-playback的使用，Spotify客户端核心组件实现高效音乐流媒体处理

安装

在项目目录中运行以下Cargo命令：

cargo add librespot-playback

或者将以下行添加到您的Cargo.toml：

librespot-playback = "0.6.0"

基本使用示例

use librespot_playback::player::Player;
use librespot_core::{session::Session, config::SessionConfig};
use librespot_connect::spirc::Spirc;
use librespot_audio::AudioDecrypt;

#[tokio::main]
async fn main() {
    // 创建会话配置
    let session_config = SessionConfig::default();
    
    // 创建Spotify会话 (需要提供用户名和密码)
    let session = Session::new(session_config, None)
        .connect_username("your_username", "your_password")
        .await
        .expect("Failed to create session");

    // 创建音频后端 (这里使用Rodio作为示例)
    let audio_backend = librespot_playback::audio_backend::find(Some("rodio")).unwrap();
    
    // 创建播放器配置
    let player_config = librespot_playback::config::PlayerConfig {
        bitrate: librespot_playback::bitrate::Bitrate::Bitrate320,
        ..Default::default()
    };

    // 创建播放器
    let (mut player, _) = Player::new(
        player_config,
        session.clone(),
        audio_backend,
        move || (AudioDecrypt::default(), None),
    );

    // 创建SPIRC实例 (Spotify连接协议)
    let (spirc, _spirc_task) = Spirc::new(
        librespot_connect::config::ConnectConfig::default(),
        session,
        player,
        None,
    );

    // 现在你可以通过spirc控制播放
    // 例如: spirc.play(), spirc.pause(), spirc.seek(), 等等

    // 保持程序运行
    tokio::time::sleep(tokio::time::Duration::from_secs(3600)).await;
}

高级功能示例

use librespot_playback::player::PlayerEvent;
use futures::StreamExt;

// 在播放器创建后添加事件处理
let (player, mut player_events) = Player::new(
    player_config,
    session.clone(),
    audio_backend,
    move || (AudioDecrypt::default(), None),
);

tokio::spawn(async move {
    while let Some(event) = player_events.next().await {
        match event {
            PlayerEvent::Started { track_id, .. } => {
                println!("播放开始: {:?}", track_id);
            }
            PlayerEvent::Stopped { track_id } => {
                println!("播放停止: {:?}", track_id);
            }
            PlayerEvent::Loading { track_id } => {
                println!("加载中: {:?}", track_id);
            }
            PlayerEvent::Playing { position_ms, duration_ms, .. } => {
                println!("播放中: {}/{} ms", position_ms, duration_ms);
            }
            PlayerEvent::Paused { position_ms, duration_ms, .. } => {
                println!("已暂停: {}/{} ms", position_ms, duration_ms);
            }
            PlayerEvent::EndOfTrack { .. } => {
                println!("曲目结束");
            }
            _ => {}
        }
    }
});

完整示例demo

use librespot_playback::{player::Player, config::PlayerConfig, audio_backend};
use librespot_core::{session::{Session, SessionConfig}, spotify_id::SpotifyId};
use librespot_connect::spirc::Spirc;
use librespot_audio::AudioDecrypt;
use librespot_metadata::Metadata;
use futures::StreamExt;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. 配置Spotify会话
    let session_config = SessionConfig::default();
    
    // 2. 创建Spotify会话 (替换为你的实际凭据)
    let session = Session::new(session_config, None)
        .connect_username("your_spotify_username", "your_spotify_password")
        .await?;

    // 3. 设置音频后端 (这里使用Rodio)
    let audio_backend = audio_backend::find(Some("rodio"))?;
    
    // 4. 配置播放器参数
    let player_config = PlayerConfig {
        bitrate: librespot_playback::bitrate::Bitrate::Bitrate320,
        normalisation: true,  // 启用音量归一化
        normalisation_pregain: -10.0,  // 归一化预增益
        ..Default::default()
    };

    // 5. 创建播放器并获取事件流
    let (player, mut player_events) = Player::new(
        player_config.clone(),
        session.clone(),
        audio_backend,
        move || (AudioDecrypt::default(), None),
    );

    // 6. 创建SPIRC控制器
    let (spirc, spirc_task) = Spirc::new(
        librespot_connect::config::ConnectConfig::default(),
        session,
        player,
        None,
    );

    // 7. 处理播放器事件 (异步任务)
    tokio::spawn(async move {
        while let Some(event) = player_events.next().await {
            match event {
                PlayerEvent::Started { track_id, .. } => {
                    println!("▶️ 开始播放: {}", track_id.to_base62());
                }
                PlayerEvent::Playing { position_ms, duration_ms, .. } => {
                    let progress = (position_ms as f32 / duration_ms as f32) * 100.0;
                    println!("⏩ 播放进度: {:.1}% ({}ms/{}ms)", 
                        progress, position_ms, duration_ms);
                }
                PlayerEvent::Paused { .. } => {
                    println!("⏸ 播放暂停");
                }
                PlayerEvent::EndOfTrack { .. } => {
                    println!("⏹ 曲目结束");
                }
                PlayerEvent::Loading { .. } => {
                    println!("⏳ 加载中...");
                }
                _ => {}
            }
        }
    });

    // 8. 示例: 播放特定曲目
    let track_id = SpotifyId::from_base62("7xGfFoTpQ2E7fRF5lH8H1A")?; // 示例曲目ID
    spirc.play(track_id, None, None);

    // 9. 保持程序运行
    sleep(Duration::from_secs(3600)).await;
    
    // 10. 清理
    drop(spirc_task);
    Ok(())
}

注意事项

1. librespot-playback是librespot项目的一部分，该项目是Spotify客户端的开源实现
2. 使用此库需要有效的Spotify Premium账户
3. 该库支持多种音频后端，包括rodio、alsa、pulseaudio等
4. 支持多种比特率选项(96kbps, 160kbps, 320kbps)
5. 提供了完整的播放控制API和事件系统

完整示例展示了如何:

• 配置并连接Spotify会话
• 设置音频播放参数
• 处理播放器事件
• 控制播放特定曲目
• 实现基本的播放状态监控

实际使用时需要:

1. 替换为有效的Spotify账户凭据
2. 根据需要选择音频后端
3. 调整播放参数如比特率、音量归一化等
4. 实现更复杂的播放控制逻辑