426 lines
14 KiB
TypeScript
426 lines
14 KiB
TypeScript
import type { AudioPlayer, AudioResource, VoiceConnection } from '@discordjs/voice';
|
|
import {
|
|
createAudioPlayer,
|
|
createAudioResource,
|
|
entersState,
|
|
joinVoiceChannel,
|
|
AudioPlayerStatus,
|
|
NoSubscriberBehavior,
|
|
StreamType,
|
|
VoiceConnectionStatus,
|
|
} from '@discordjs/voice';
|
|
import { isAbsolute, resolve } from 'node:path';
|
|
|
|
import { AudioManagerConfigError, AudioManagerStateError } from './errors';
|
|
import { startFfmpeg, type FfmpegProcessHandle } from './ffmpeg';
|
|
import type {
|
|
AudioManagerOptions,
|
|
AudioSource,
|
|
PlaybackState,
|
|
ResolvedAudioSource,
|
|
VoiceConnectionOptions,
|
|
} from './types';
|
|
|
|
const DEFAULT_CONNECT_TIMEOUT_MS = 20_000;
|
|
const DISCONNECT_RECOVERY_TIMEOUT_MS = 5_000;
|
|
const MAX_TIMER_DELAY_MS = 2_147_483_647;
|
|
|
|
function assertValidTimerDelay(value: number, optionName: string): void {
|
|
if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_TIMER_DELAY_MS) {
|
|
throw new AudioManagerConfigError(
|
|
`${optionName} must be an integer between 1 and ${MAX_TIMER_DELAY_MS} milliseconds.`,
|
|
);
|
|
}
|
|
}
|
|
|
|
function assertValidVolumePercent(value: number): void {
|
|
if (!Number.isFinite(value) || value < 0 || value > 100) {
|
|
throw new AudioManagerConfigError('Volume must be between 0 and 100 percent.');
|
|
}
|
|
}
|
|
|
|
export default class AudioManager implements Disposable {
|
|
private readonly audioPlayer: AudioPlayer;
|
|
|
|
private connection: VoiceConnection | undefined;
|
|
private resource: AudioResource | undefined;
|
|
private ffmpeg: FfmpegProcessHandle | undefined;
|
|
private connectAttempt: AbortController | undefined;
|
|
private renewTimer: NodeJS.Timeout | undefined;
|
|
private playbackState: PlaybackState = 'idle';
|
|
private connectionOptions: VoiceConnectionOptions | undefined;
|
|
private audioSource: AudioSource | undefined;
|
|
private readonly options: Required<Pick<AudioManagerOptions, 'connectTimeoutMs'>> &
|
|
Omit<AudioManagerOptions, 'connectTimeoutMs'>;
|
|
|
|
public constructor(options: AudioManagerOptions = {}) {
|
|
const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
|
|
assertValidTimerDelay(connectTimeoutMs, 'connectTimeoutMs');
|
|
|
|
if (typeof options.renewIntervalMs === 'number') {
|
|
assertValidTimerDelay(options.renewIntervalMs, 'renewIntervalMs');
|
|
}
|
|
|
|
if (options.volume?.initialPercent !== undefined) {
|
|
if (options.volume.enabled !== true) {
|
|
throw new AudioManagerConfigError('volume.initialPercent requires volume.enabled to be true.');
|
|
}
|
|
assertValidVolumePercent(options.volume.initialPercent);
|
|
}
|
|
|
|
this.options = {
|
|
...options,
|
|
connectTimeoutMs,
|
|
};
|
|
this.connectionOptions = options.connection;
|
|
this.audioSource = options.source;
|
|
this.audioPlayer = createAudioPlayer({
|
|
behaviors: {
|
|
noSubscriber: NoSubscriberBehavior.Play,
|
|
},
|
|
});
|
|
this.audioPlayer.on('error', (error) => {
|
|
this.finishPlayback(error.resource);
|
|
this.reportError(error);
|
|
});
|
|
this.audioPlayer.on(AudioPlayerStatus.Idle, (oldState) => {
|
|
if ('resource' in oldState) {
|
|
this.finishPlayback(oldState.resource);
|
|
}
|
|
});
|
|
}
|
|
|
|
public get state(): PlaybackState {
|
|
return this.playbackState;
|
|
}
|
|
|
|
public get isPlaying(): boolean {
|
|
return this.playbackState === 'playing';
|
|
}
|
|
|
|
public get isConnected(): boolean {
|
|
return this.connection?.state.status === VoiceConnectionStatus.Ready;
|
|
}
|
|
|
|
public setConnection(options: VoiceConnectionOptions): void {
|
|
this.assertNotDisposed();
|
|
this.connectionOptions = options;
|
|
}
|
|
|
|
public setSource(source: AudioSource): void {
|
|
this.assertNotDisposed();
|
|
this.audioSource = source;
|
|
}
|
|
|
|
public async connect(): Promise<void> {
|
|
this.assertNotDisposed();
|
|
|
|
if (!this.connectionOptions) {
|
|
throw new AudioManagerConfigError('Voice connection options are required before connecting.');
|
|
}
|
|
|
|
this.cancelConnectAttempt();
|
|
const attempt = new AbortController();
|
|
this.connectAttempt = attempt;
|
|
this.clearRenewTimer();
|
|
this.playbackState = 'connecting';
|
|
|
|
const previousConnection = this.connection;
|
|
this.connection = undefined;
|
|
let connection: VoiceConnection | undefined;
|
|
|
|
try {
|
|
previousConnection?.destroy();
|
|
connection = joinVoiceChannel({
|
|
guildId: this.connectionOptions.guildId,
|
|
channelId: this.connectionOptions.channelId,
|
|
adapterCreator: this.connectionOptions.adapterCreator,
|
|
});
|
|
this.connection = connection;
|
|
this.observeConnection(connection);
|
|
connection.subscribe(this.audioPlayer);
|
|
|
|
await entersState(
|
|
connection,
|
|
VoiceConnectionStatus.Ready,
|
|
AbortSignal.any([attempt.signal, AbortSignal.timeout(this.options.connectTimeoutMs)]),
|
|
);
|
|
} catch (error) {
|
|
if (this.connectAttempt !== attempt) {
|
|
throw new AudioManagerStateError('Voice connection was stopped before it became ready.', {
|
|
cause: error,
|
|
});
|
|
}
|
|
|
|
this.connectAttempt = undefined;
|
|
if (connection && connection.state.status !== VoiceConnectionStatus.Destroyed) {
|
|
connection.destroy();
|
|
}
|
|
if (this.connection === connection) {
|
|
this.connection = undefined;
|
|
}
|
|
this.playbackState = 'stopped';
|
|
throw error;
|
|
}
|
|
|
|
if (this.connectAttempt !== attempt || this.connection !== connection) {
|
|
throw new AudioManagerStateError('Voice connection was stopped before it became ready.');
|
|
}
|
|
|
|
this.connectAttempt = undefined;
|
|
this.playbackState = 'ready';
|
|
this.scheduleRenewal();
|
|
}
|
|
|
|
public async play(source?: AudioSource): Promise<void> {
|
|
this.assertNotDisposed();
|
|
|
|
if (source) {
|
|
this.setSource(source);
|
|
}
|
|
|
|
if (!this.isConnected) {
|
|
throw new AudioManagerStateError('A voice connection is required before audio can be played.');
|
|
}
|
|
|
|
const resolvedSource = this.resolveSource();
|
|
this.stopCurrentPlayback();
|
|
this.ffmpeg = startFfmpeg(resolvedSource.input, this.options.ffmpeg);
|
|
const ffmpeg = this.ffmpeg;
|
|
try {
|
|
await ffmpeg.ready;
|
|
if (this.ffmpeg !== ffmpeg) {
|
|
throw new AudioManagerStateError('Playback was stopped before ffmpeg became ready.');
|
|
}
|
|
this.resource = createAudioResource(ffmpeg.process.stdout, {
|
|
inputType: StreamType.Raw,
|
|
inlineVolume: this.options.volume?.enabled === true,
|
|
});
|
|
} catch (error) {
|
|
if (this.ffmpeg !== ffmpeg) {
|
|
throw error instanceof AudioManagerStateError
|
|
? error
|
|
: new AudioManagerStateError('Playback was stopped before ffmpeg became ready.', {
|
|
cause: error,
|
|
});
|
|
}
|
|
|
|
this.stopCurrentPlayback();
|
|
throw error;
|
|
}
|
|
|
|
try {
|
|
if (this.options.volume?.enabled === true && this.options.volume.initialPercent !== undefined) {
|
|
this.setVolume(this.options.volume.initialPercent);
|
|
}
|
|
this.audioPlayer.play(this.resource);
|
|
this.playbackState = 'playing';
|
|
} catch (error) {
|
|
this.stopCurrentPlayback();
|
|
this.playbackState = 'ready';
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
public async start(): Promise<void> {
|
|
await this.connect();
|
|
await this.play();
|
|
}
|
|
|
|
public pause(): void {
|
|
this.assertNotDisposed();
|
|
|
|
if (this.playbackState !== 'playing') {
|
|
throw new AudioManagerStateError('Audio can only be paused while it is playing.');
|
|
}
|
|
|
|
this.audioPlayer.pause();
|
|
this.playbackState = 'paused';
|
|
}
|
|
|
|
public resume(): void {
|
|
this.assertNotDisposed();
|
|
|
|
if (this.playbackState !== 'paused') {
|
|
throw new AudioManagerStateError('Audio can only be resumed while it is paused.');
|
|
}
|
|
|
|
this.audioPlayer.unpause();
|
|
this.playbackState = 'playing';
|
|
}
|
|
|
|
public async stop(): Promise<void> {
|
|
if (this.playbackState === 'disposed') {
|
|
return;
|
|
}
|
|
|
|
this.cancelConnectAttempt();
|
|
this.clearRenewTimer();
|
|
this.stopCurrentPlayback();
|
|
this.audioPlayer.stop(true);
|
|
this.connection?.disconnect();
|
|
this.connection?.destroy();
|
|
this.connection = undefined;
|
|
this.playbackState = 'stopped';
|
|
}
|
|
|
|
public setVolume(volumeInPercent: number): void {
|
|
this.assertNotDisposed();
|
|
|
|
if (this.options.volume?.enabled !== true) {
|
|
throw new AudioManagerStateError('Volume control requires volume.enabled to be true.');
|
|
}
|
|
|
|
assertValidVolumePercent(volumeInPercent);
|
|
|
|
if (!this.resource?.volume) {
|
|
throw new AudioManagerStateError('No audio resource with volume control is currently active.');
|
|
}
|
|
|
|
this.resource.volume.setVolume(volumeInPercent / 100);
|
|
}
|
|
|
|
public dispose(): void {
|
|
if (this.playbackState === 'disposed') {
|
|
return;
|
|
}
|
|
|
|
this.cancelConnectAttempt();
|
|
this.clearRenewTimer();
|
|
this.stopCurrentPlayback();
|
|
this.audioPlayer.stop(true);
|
|
this.connection?.destroy();
|
|
this.connection = undefined;
|
|
this.connectionOptions = undefined;
|
|
this.audioSource = undefined;
|
|
this.playbackState = 'disposed';
|
|
}
|
|
|
|
public [Symbol.dispose](): void {
|
|
this.dispose();
|
|
}
|
|
|
|
private resolveSource(): ResolvedAudioSource {
|
|
if (!this.audioSource) {
|
|
throw new AudioManagerConfigError('Audio source is required before playback can start.');
|
|
}
|
|
|
|
if (this.audioSource.type === 'url') {
|
|
try {
|
|
return {
|
|
input: new URL(this.audioSource.url).toString(),
|
|
source: this.audioSource,
|
|
};
|
|
} catch (error) {
|
|
throw new AudioManagerConfigError('Invalid audio source URL.', { cause: error });
|
|
}
|
|
}
|
|
|
|
return {
|
|
input: isAbsolute(this.audioSource.path)
|
|
? this.audioSource.path
|
|
: resolve(process.cwd(), this.audioSource.path),
|
|
source: this.audioSource,
|
|
};
|
|
}
|
|
|
|
private scheduleRenewal(): void {
|
|
const renewIntervalMs = this.options.renewIntervalMs;
|
|
|
|
if (renewIntervalMs === undefined || renewIntervalMs === false) {
|
|
return;
|
|
}
|
|
|
|
this.renewTimer = setTimeout(() => {
|
|
void this.start().catch((error: unknown) => {
|
|
if (this.playbackState === 'disposed') {
|
|
return;
|
|
}
|
|
|
|
this.clearRenewTimer();
|
|
this.stopCurrentPlayback();
|
|
this.audioPlayer.stop(true);
|
|
this.connection?.disconnect();
|
|
this.connection?.destroy();
|
|
this.connection = undefined;
|
|
this.playbackState = 'stopped';
|
|
this.reportError(error);
|
|
});
|
|
}, renewIntervalMs);
|
|
|
|
if (typeof this.renewTimer.unref === 'function') {
|
|
this.renewTimer.unref();
|
|
}
|
|
}
|
|
|
|
private observeConnection(connection: VoiceConnection): void {
|
|
connection.on('error', (error) => {
|
|
this.reportError(error);
|
|
});
|
|
connection.on(VoiceConnectionStatus.Disconnected, () => this.handleDisconnectedConnection(connection));
|
|
}
|
|
|
|
private async handleDisconnectedConnection(connection: VoiceConnection): Promise<void> {
|
|
try {
|
|
await Promise.race([
|
|
entersState(connection, VoiceConnectionStatus.Signalling, DISCONNECT_RECOVERY_TIMEOUT_MS),
|
|
entersState(connection, VoiceConnectionStatus.Connecting, DISCONNECT_RECOVERY_TIMEOUT_MS),
|
|
]);
|
|
} catch (error) {
|
|
if (this.connection !== connection) {
|
|
return;
|
|
}
|
|
|
|
this.clearRenewTimer();
|
|
this.stopCurrentPlayback();
|
|
this.audioPlayer.stop(true);
|
|
this.connection = undefined;
|
|
if (connection.state.status !== VoiceConnectionStatus.Destroyed) {
|
|
connection.destroy();
|
|
}
|
|
this.playbackState = 'stopped';
|
|
this.reportError(error);
|
|
}
|
|
}
|
|
|
|
private finishPlayback(resource: AudioResource): void {
|
|
if (this.resource !== resource) {
|
|
return;
|
|
}
|
|
|
|
this.stopCurrentPlayback();
|
|
if (this.playbackState !== 'disposed') {
|
|
this.playbackState = this.isConnected ? 'ready' : 'stopped';
|
|
}
|
|
}
|
|
|
|
private reportError(error: unknown): void {
|
|
this.options.onError?.(error instanceof Error ? error : new Error(String(error)));
|
|
}
|
|
|
|
private clearRenewTimer(): void {
|
|
if (this.renewTimer) {
|
|
clearTimeout(this.renewTimer);
|
|
this.renewTimer = undefined;
|
|
}
|
|
}
|
|
|
|
private cancelConnectAttempt(): void {
|
|
this.connectAttempt?.abort();
|
|
this.connectAttempt = undefined;
|
|
}
|
|
|
|
private stopCurrentPlayback(): void {
|
|
this.resource?.playStream.destroy();
|
|
this.resource = undefined;
|
|
this.ffmpeg?.stop();
|
|
this.ffmpeg = undefined;
|
|
}
|
|
|
|
private assertNotDisposed(): void {
|
|
if (this.playbackState === 'disposed') {
|
|
throw new AudioManagerStateError('AudioManager has been disposed.');
|
|
}
|
|
}
|
|
}
|