StreamDispatcher

Manages audio playback and streaming for a voice connection. Handles the audio player, voice connection lifecycle, and DSP filters.

Constructor

new StreamDispatcher(
  connection: VoiceConnection,
  channel: VoiceChannel | StageChannel,
  queue: GuildQueue,
  connectionTimeout?: number,
  audioPlayer?: AudioPlayer
)

connection

VoiceConnection

required

The Discord voice connection

channel

VoiceChannel | StageChannel

required

The voice or stage channel being connected to

queue

GuildQueue

required

The guild queue instance

connectionTimeout

number

default:20000

Timeout in milliseconds for connection state changes

audioPlayer

AudioPlayer

Optional audio player instance. If not provided, a new one will be created

Properties

voiceConnection

VoiceConnection

The underlying Discord voice connection

audioPlayer

AudioPlayer

The Discord.js audio player instance

channel

VoiceChannel | StageChannel

The voice channel the bot is connected to

audioResource

AudioResource<Track> | null

Currently playing audio resource

dsp

FiltersChain

Digital Signal Processing filters chain

queue

GuildQueue

Reference to the parent guild queue

connectionTimeout

number

Timeout duration for voice connection operations

paused

boolean

Whether the player is manually paused. Can be set to pause/resume

status

AudioPlayerStatus

Current status of the audio player

volume

number

Current playback volume (0-100)

streamTime

number

Current playback time in milliseconds

resampler

Resampler | undefined

Audio resampler from the DSP chain

filters

Filters | undefined

DSP filters from the filter chain

biquad

Biquad | null

Biquad filter from the DSP chain

equalizer

Equalizer | null

Equalizer from the DSP chain

compressor

Compressor | null

Audio compressor from the DSP chain

reverb

Reverb | null

Reverb effect from the DSP chain

seeker

Seeker | null

PCM seeker for track seeking

Methods

createStream

Creates an audio resource from a readable stream with DSP filters.

createStream(src: Readable, ops: CreateStreamOps): Promise<AudioResource<Track>>

src

Readable

required

The source audio stream

ops

CreateStreamOps

required

Stream creation options including:

type: Stream type (e.g., StreamType.Arbitrary, StreamType.OggOpus)
data: Track metadata
disableVolume: Disable volume transformer
disableEqualizer: Disable equalizer
disableBiquad: Disable biquad filter
disableCompressor: Disable compressor
disableResampler: Disable resampler
disableReverb: Disable reverb
disableSeeker: Disable seeker
eq: Equalizer band configuration
biquadFilter: Biquad filter type
disableFilters: Disable all DSP filters
defaultFilters: Default PCM filters to apply
volume: Initial volume (0-100)
sampleRate: Target sample rate
sampleRateFilters: Resampler filter preset
compressor: Compressor parameters
reverb: Reverb parameters
seeker: Seeker parameters

return

Promise<AudioResource<Track>>

The created audio resource ready for playback

Example:

const stream = getAudioStream(); // Your audio stream
const resource = await dispatcher.createStream(stream, {
  type: StreamType.Arbitrary,
  data: track,
  volume: 80,
  eq: EqualizerConfigurationPreset.Rock,
  compressor: {
    threshold: -20,
    ratio: 3,
    attack: 0.003,
    release: 0.25,
    makeupGain: 1,
    kneeWidth: 4
  }
});

playStream

Plays an audio resource through the voice connection.

playStream(resource?: AudioResource<Track>): Promise<StreamDispatcher>

resource

AudioResource<Track>

The audio resource to play. Defaults to the current audio resource

return

Promise<StreamDispatcher>

Returns this dispatcher instance for chaining

Example:

const resource = await dispatcher.createStream(stream, options);
await dispatcher.playStream(resource);

pause

Pauses the current playback.

pause(interpolateSilence?: boolean): boolean

interpolateSilence

boolean

default:false

If true, plays 5 packets of silence after pausing to prevent audio glitches

return

boolean

Returns true if successfully paused

Example:

// Pause without silence interpolation
dispatcher.pause();

// Pause with silence interpolation
dispatcher.pause(true);

resume

Resumes paused playback.

resume(): boolean

return

boolean

Returns true if successfully resumed

Example:

dispatcher.resume();

setVolume

Sets the playback volume.

setVolume(value: number): boolean

value

number

required

Volume level from 0 to 100

return

boolean

Returns true if volume was set successfully

Example:

// Set volume to 75%
dispatcher.setVolume(75);

// Mute
dispatcher.setVolume(0);

// Max volume
dispatcher.setVolume(100);

disconnect

Disconnects from the voice channel.

disconnect(): void

Example:

dispatcher.disconnect();

destroy

Destroys the dispatcher and cleans up all resources.

destroy(): void

Example:

dispatcher.destroy();

end

Stops the current playback.

end(): void

Example:

dispatcher.end();

isPaused

Checks if the player is paused (manually or automatically).

isPaused(): boolean

return

boolean

Returns true if paused

isBuffering

Checks if the player is currently buffering.

isBuffering(): boolean

return

boolean

Returns true if buffering

isPlaying

Checks if the player is currently playing.

isPlaying(): boolean

return

boolean

Returns true if playing

isIdle

Checks if the player is idle.

isIdle(): boolean

return

boolean

Returns true if idle

isDestroyed

Checks if the voice connection has been destroyed.

isDestroyed(): boolean

return

boolean

Returns true if destroyed

isDisconnected

Checks if the voice connection is disconnected.

isDisconnected(): boolean

return

boolean

Returns true if disconnected

isReady

Checks if the voice connection is ready.

isReady(): boolean

return

boolean

Returns true if ready

isSignalling

Checks if the voice connection is in signalling state.

isSignalling(): boolean

return

boolean

Returns true if signalling

isConnecting

Checks if the voice connection is connecting.

isConnecting(): boolean

return

boolean

Returns true if connecting

Events

The StreamDispatcher emits the following events:

error

(error: AudioPlayerError) => void

Emitted when an error occurs in the audio player or voice connection

debug

(message: string) => void

Emitted for debug messages

start

(resource: AudioResource<Track>) => void

Emitted when playback starts

finish

(resource: AudioResource<Track>) => void

Emitted when playback finishes

dsp

(filters: PCMFilters[]) => void

Emitted when DSP filters are updated

eqBands

(filters: EqualizerBand[]) => void

Emitted when equalizer bands are updated

sampleRate

(filters: ResampleParameters) => void

Emitted when sample rate parameters are updated

biquad

(filters: BiquadFilters) => void

Emitted when biquad filters are updated

compressor

(filters: CompressorParameters) => void

Emitted when compressor parameters are updated

reverb

(filters: ReverbParameters) => void

Emitted when reverb parameters are updated

seeker

(filters: SeekerParameters) => void

Emitted when seeker parameters are updated

volume

(volume: number) => void

Emitted when volume is changed

destroyed

() => void

Emitted when the dispatcher is destroyed

Usage Example

import { StreamDispatcher } from 'discord-player';

// Listen to events
dispatcher.on('start', (resource) => {
  console.log('Started playing:', resource.metadata.title);
});

dispatcher.on('finish', (resource) => {
  console.log('Finished playing:', resource.metadata.title);
});

dispatcher.on('error', (error) => {
  console.error('Playback error:', error);
});

dispatcher.on('volume', (volume) => {
  console.log('Volume changed to:', volume);
});

// Control playback
if (dispatcher.isPlaying()) {
  dispatcher.pause();
}

if (dispatcher.isPaused()) {
  dispatcher.resume();
}

// Adjust volume
dispatcher.setVolume(50);

// Check playback time
console.log('Current position:', dispatcher.streamTime, 'ms');

// Check connection status
if (dispatcher.isReady()) {
  console.log('Voice connection is ready');
}

GuildQueueAudioFilters - Audio filters management
GuildQueue - Guild queue class
Track - Track class

Core Classes

Queue Management

Audio Processing

Extractors

Hooks

Utilities

StreamDispatcher