Documentation
¶
Overview ¶
Package audio is the playback engine: it streams, decrypts and decodes Deezer audio (MP3 + FLAC) into a PCM ring that an output device drains. Supports seek, per-track ReplayGain, gapless transitions and (experimental) crossfade. In-memory by default; SetStreamCache attaches an opt-in on-disk cache of the raw (still-encrypted) CDN bytes for full tracks — decrypted audio is never written to disk.
The output device is abstracted behind the `output` interface so the backend is build-tag-selected: malgo/miniaudio by default (adds output-device selection), or oto under the `otosink` tag — used for the macOS GUI, where malgo's CoreAudio callback runs unreliably inside the c-archive.
Index ¶
- Variables
- type Device
- type Player
- func (p *Player) AddVolume(delta float64) float64
- func (p *Player) CancelSleepTimer()
- func (p *Player) ClearPreload()
- func (p *Player) Close()
- func (p *Player) CrossfadeMS() int
- func (p *Player) CurrentDevice() string
- func (p *Player) Devices() ([]Device, error)
- func (p *Player) DurationMS() int64
- func (p *Player) EQBands() []float64
- func (p *Player) EQEnabled() bool
- func (p *Player) EQGains() []float64
- func (p *Player) EQPreampDB() float64
- func (p *Player) EQPreset() string
- func (p *Player) Format() string
- func (p *Player) Gapless() bool
- func (p *Player) IsPreview() bool
- func (p *Player) LastError() string
- func (p *Player) MonoDownmix() bool
- func (p *Player) Pause()
- func (p *Player) Play(plan *deezer.StreamPlan, durationMS int64) error
- func (p *Player) PositionMS() int64
- func (p *Player) Preload(plan *deezer.StreamPlan, durationMS int64)
- func (p *Player) ReplayGain() bool
- func (p *Player) Resume()
- func (p *Player) SeekMS(ms int64)
- func (p *Player) SetCrossfadeMS(ms int)
- func (p *Player) SetDevice(id string) error
- func (p *Player) SetEQEnabled(on bool)
- func (p *Player) SetEQGain(band int, db float64) error
- func (p *Player) SetEQGains(db []float64) error
- func (p *Player) SetEQPreamp(db float64)
- func (p *Player) SetEQPreset(name string) error
- func (p *Player) SetGapless(on bool)
- func (p *Player) SetMonoDownmix(on bool)
- func (p *Player) SetOnFinish(fn func())
- func (p *Player) SetOutputSuspended(on bool) error
- func (p *Player) SetReplayGain(on bool)
- func (p *Player) SetSleepTimer(d time.Duration, endOfTrack bool)
- func (p *Player) SetStreamCache(c StreamCache)
- func (p *Player) SetVolume(v float64)
- func (p *Player) SleepActive() bool
- func (p *Player) SleepEndOfTrack() bool
- func (p *Player) SleepRemainingMS() int64
- func (p *Player) State() State
- func (p *Player) Stop()
- func (p *Player) TogglePause()
- func (p *Player) Volume() float64
- type State
- type StreamCache
Constants ¶
This section is empty.
Variables ¶
var EQPresetNames = []string{
"flat", "bass-boost", "bass-reducer", "treble-boost", "vocal",
"rock", "pop", "jazz", "classical", "electronic",
}
EQPresetNames is the preset order every client shows (core-owned so the UIs stay identical). "custom" is implicit: any manual band edit switches to it.
var ErrOffline = errors.New("offline: track not cached and no CDN URL available")
ErrOffline is returned when attempting to play a track offline (empty CDN URL) but the track is not present in the local StreamCache.
Functions ¶
This section is empty.
Types ¶
type Player ¶
type Player struct {
// contains filtered or unexported fields
}
Player owns the malgo context + one output device and plays a current source, optionally with a preloaded next source for gapless/crossfade.
func (*Player) CancelSleepTimer ¶
func (p *Player) CancelSleepTimer()
CancelSleepTimer disarms the sleep timer and restores full volume.
func (*Player) ClearPreload ¶
func (p *Player) ClearPreload()
ClearPreload discards any preloaded next source. Call when the upcoming track is no longer determined (e.g. shuffle/repeat was toggled after a linear-next was preloaded) so a stale preload can't be gaplessly swapped in.
func (*Player) CrossfadeMS ¶
func (*Player) CurrentDevice ¶
CurrentDevice returns the selected device id ("" = default).
func (*Player) DurationMS ¶
func (*Player) EQPreampDB ¶
EQPreampDB returns the preamp in dB.
func (*Player) IsPreview ¶
IsPreview reports whether the current track is Deezer's 30-second preview (the free-account fallback) rather than the full, entitled stream.
func (*Player) MonoDownmix ¶
MonoDownmix reports whether mono downmix is on.
func (*Player) Play ¶
func (p *Player) Play(plan *deezer.StreamPlan, durationMS int64) error
Play starts a track immediately, replacing anything current.
func (*Player) PositionMS ¶
func (*Player) Preload ¶
func (p *Player) Preload(plan *deezer.StreamPlan, durationMS int64)
Preload prepares the next track so the transition is gapless/crossfaded. It is a no-op if gapless is disabled.
func (*Player) ReplayGain ¶
func (*Player) SetCrossfadeMS ¶
func (*Player) SetEQEnabled ¶
SetEQEnabled turns the equalizer on/off (mono downmix is independent).
func (*Player) SetEQGain ¶
SetEQGain sets one band's gain in dB (clamped to ±12). Preset becomes "custom".
func (*Player) SetEQGains ¶
SetEQGains sets all band gains in dB (clamped). Preset becomes "custom".
func (*Player) SetEQPreamp ¶
SetEQPreamp sets the output preamp in dB (clamped to ±12), for taming clipping when several bands are boosted.
func (*Player) SetEQPreset ¶
SetEQPreset applies a named preset's band gains.
func (*Player) SetGapless ¶
SetGapless enables/disables gapless transitions between tracks.
func (*Player) SetMonoDownmix ¶
SetMonoDownmix folds stereo to mono (accessibility / single-speaker setups).
func (*Player) SetOnFinish ¶
func (p *Player) SetOnFinish(fn func())
func (*Player) SetOutputSuspended ¶
SetOutputSuspended releases (on=true) or restores (on=false) the OS audio output without tearing down playback state (decoder, ring, position). Use it on audio-focus loss/interruption (e.g. iOS): playback resumes where it left off. Safe to call from any goroutine.
func (*Player) SetReplayGain ¶
func (*Player) SetSleepTimer ¶
SetSleepTimer arms the sleep timer. When endOfTrack is true the player pauses once the current track finishes (d is ignored); otherwise it fades out over the last few seconds and pauses after d elapses. d <= 0 with endOfTrack false cancels any armed timer.
func (*Player) SetStreamCache ¶
func (p *Player) SetStreamCache(c StreamCache)
SetStreamCache attaches an optional raw-stream cache used by every source created afterwards (Play/Preload). nil — the default — disables caching. Only full encrypted track streams are cached; previews and plain passthrough streams (podcasts) never touch the cache.
Call it once at startup, before any playback: the field is read without synchronization when sources are created, so SetStreamCache is NOT safe to call concurrently with Play/Preload or while a track is playing.
func (*Player) SleepActive ¶
SleepActive reports whether a sleep timer is armed.
func (*Player) SleepEndOfTrack ¶
SleepEndOfTrack reports whether the armed timer is in end-of-track mode.
func (*Player) SleepRemainingMS ¶
SleepRemainingMS returns the milliseconds until the timer fires: for duration mode the wall-clock remainder, for end-of-track mode the current track's remaining time. Returns 0 when no timer is armed.
func (*Player) TogglePause ¶
func (p *Player) TogglePause()
type StreamCache ¶
type StreamCache interface {
// Get returns a reader over the cached body and its size when key is
// present. The caller must close the reader.
Get(key string) (io.ReadCloser, int64, bool)
// TeeReader returns a reader that consumes src while mirroring the bytes
// into the cache under key, committing the entry on clean EOF and
// discarding the partial write on any read/write error. Implementations
// return src unchanged when they cannot start the write (e.g. one is
// already in progress for key).
TeeReader(key string, src io.Reader) io.Reader
}
StreamCache is an optional on-disk cache of raw CDN stream bodies, keyed by "trackID.format" (e.g. "12345.MP3_320"). The stored bytes are exactly what the CDN served — still stripe-encrypted ciphertext for tracks — so nothing decrypted ever lands on disk; decryption still happens in the normal playback pipeline. *mediacache.Cache satisfies this interface; the audio package depends only on the interface so the cache stays a pluggable opt-in.
Source Files