Crate pleezer

Headless streaming player for the Deezer Connect protocol.

pleezer is a library and application that implements the Deezer Connect protocol, enabling remote-controlled audio playback of Deezer content. It provides:

Core Features

• Remote Control: Acts as a receiver for Deezer Connect, allowing control from official Deezer apps
• Audio Playback: High-quality audio streaming with gapless playback support
• Format Support: Handles MP3 and FLAC formats based on subscription level
• Volume Normalization: Optional audio leveling with configurable target gain

Architecture

The library is organized into several key modules:

• Connection Management

  • http: Manages HTTP connections and cookies
  • gateway: Handles API authentication and requests
  • remote: Implements Deezer Connect protocol

• Audio Processing

  • audio_file: Unified interface for audio stream handling
  • decrypt: Handles encrypted content
  • decoder: Audio format decoding
  • normalize: Audio leveling and dynamic range control
  • player: Controls audio playback and queues
  • track: Manages track metadata and downloads

• Authentication

  • arl: ARL token management
  • tokens: Session token handling

• Configuration

  • config: Application settings
  • proxy: Network proxy support

• Protocol

  • events: Event system for state changes
  • protocol: Deezer Connect message types

• System Integration

  • signal: Signal handling (SIGTERM, SIGHUP)
  • error: Error types and handling
  • util: General helper functions
  • uuid: UUID generation

Example

use pleezer::{config::Config, player::Player, remote::Client};

async fn example() -> pleezer::error::Result<()> {
    // Create player with configuration
    let config = Config::new()?;
    let player = Player::new(&config, "").await?;

    // Create and start client
    let mut client = Client::new(&config, player)?;
    client.start().await?;

    Ok(())
}

Protocol Documentation

For details on the Deezer Connect protocol implementation, see the protocol and remote modules.

Error Handling

Errors are handled through the types in the error module, with most functions returning Result.

Signal Handling

The application responds to system signals:

• SIGTERM/Ctrl-C: Graceful shutdown
• SIGHUP: Configuration reload

See the signal module for details.

Concurrency

The library uses async/await for concurrency and is designed to work with the Tokio async runtime. Most operations are asynchronous and can run concurrently.

Re-exports

pub use uuid::Uuid;

Modules

arl

ARL validation and handling.

audio_file

Provides the AudioFile abstraction for handling audio stream playback.

config

Configuration and authentication for pleezer.

decoder

Audio decoder implementation using Symphonia.

decrypt

Track decryption for Deezer’s protected media content.

error

Error handling for pleezer.

events

Events emitted during Deezer Connect playback and remote control.

gateway

Gateway API client for Deezer services.

http

HTTP client with rate limiting and session management for Deezer APIs.

normalize

Audio normalization through feedforward limiting.

player

Audio playback and track management.

protocol

Protocol types and structures for Deezer services.

proxy

HTTP proxy support for HTTPS connections.

remote

Remote control protocol implementation for Deezer Connect.

signal

System signal handling for graceful shutdown and reload.

tokens

Authentication token management for Deezer users.

track

Track management and playback preparation.

util

Utility traits and functions.

uuid

UUID functionality with fast random generation.