muse/src/services/player.ts
Johannes Vääräkangas 4dbb55a721
Configurable voice channel leave behavior (#514)
Co-authored-by: Max Isom <hi@maxisom.me>
2022-02-11 20:05:02 -06:00

502 lines
13 KiB
TypeScript

import {VoiceChannel, Snowflake} from 'discord.js';
import {Readable} from 'stream';
import hasha from 'hasha';
import ytdl from 'ytdl-core';
import {WriteStream} from 'fs-capacitor';
import ffmpeg from 'fluent-ffmpeg';
import shuffle from 'array-shuffle';
import {AudioPlayer, AudioPlayerStatus, createAudioPlayer, createAudioResource, joinVoiceChannel, StreamType, VoiceConnection, VoiceConnectionStatus} from '@discordjs/voice';
import FileCacheProvider from './file-cache.js';
import debug from '../utils/debug.js';
import {prisma} from '../utils/db.js';
export interface QueuedPlaylist {
title: string;
source: string;
}
export interface QueuedSong {
title: string;
artist: string;
url: string;
length: number;
playlist: QueuedPlaylist | null;
isLive: boolean;
addedInChannelId: Snowflake;
thumbnailUrl: string | null;
requestedBy: string;
}
export enum STATUS {
PLAYING,
PAUSED,
IDLE,
}
export interface PlayerEvents {
statusChange: (oldStatus: STATUS, newStatus: STATUS) => void;
}
export default class {
public voiceConnection: VoiceConnection | null = null;
public status = STATUS.PAUSED;
public guildId: string;
private queue: QueuedSong[] = [];
private queuePosition = 0;
private audioPlayer: AudioPlayer | null = null;
private nowPlaying: QueuedSong | null = null;
private playPositionInterval: NodeJS.Timeout | undefined;
private lastSongURL = '';
private positionInSeconds = 0;
private readonly fileCache: FileCacheProvider;
private disconnectTimer: NodeJS.Timeout | null = null;
constructor(fileCache: FileCacheProvider, guildId: string) {
this.fileCache = fileCache;
this.guildId = guildId;
}
async connect(channel: VoiceChannel): Promise<void> {
this.voiceConnection = joinVoiceChannel({
channelId: channel.id,
guildId: channel.guild.id,
adapterCreator: channel.guild.voiceAdapterCreator,
});
}
disconnect(): void {
if (this.voiceConnection) {
if (this.status === STATUS.PLAYING) {
this.pause();
}
this.voiceConnection.destroy();
this.audioPlayer?.stop();
this.voiceConnection = null;
this.audioPlayer = null;
}
}
async seek(positionSeconds: number): Promise<void> {
this.status = STATUS.PAUSED;
if (this.voiceConnection === null) {
throw new Error('Not connected to a voice channel.');
}
const currentSong = this.getCurrent();
if (!currentSong) {
throw new Error('No song currently playing');
}
if (positionSeconds > currentSong.length) {
throw new Error('Seek position is outside the range of the song.');
}
const stream = await this.getStream(currentSong.url, {seek: positionSeconds});
this.audioPlayer = createAudioPlayer({
behaviors: {
// Needs to be somewhat high for livestreams
maxMissedFrames: 50,
},
});
this.voiceConnection.subscribe(this.audioPlayer);
this.audioPlayer.play(createAudioResource(stream, {
inputType: StreamType.WebmOpus,
}));
this.attachListeners();
this.startTrackingPosition(positionSeconds);
this.status = STATUS.PLAYING;
}
async forwardSeek(positionSeconds: number): Promise<void> {
return this.seek(this.positionInSeconds + positionSeconds);
}
getPosition(): number {
return this.positionInSeconds;
}
async play(): Promise<void> {
if (this.voiceConnection === null) {
throw new Error('Not connected to a voice channel.');
}
const currentSong = this.getCurrent();
if (!currentSong) {
throw new Error('Queue empty.');
}
// Cancel any pending idle disconnection
if (this.disconnectTimer) {
clearInterval(this.disconnectTimer);
this.disconnectTimer = null;
}
// Resume from paused state
if (this.status === STATUS.PAUSED && currentSong.url === this.nowPlaying?.url) {
if (this.audioPlayer) {
this.audioPlayer.unpause();
this.status = STATUS.PLAYING;
this.startTrackingPosition();
return;
}
// Was disconnected, need to recreate stream
if (!currentSong.isLive) {
return this.seek(this.getPosition());
}
}
try {
const stream = await this.getStream(currentSong.url);
this.audioPlayer = createAudioPlayer({
behaviors: {
// Needs to be somewhat high for livestreams
maxMissedFrames: 50,
},
});
this.voiceConnection.subscribe(this.audioPlayer);
const resource = createAudioResource(stream, {
inputType: StreamType.WebmOpus,
});
this.audioPlayer.play(resource);
this.attachListeners();
this.status = STATUS.PLAYING;
this.nowPlaying = currentSong;
if (currentSong.url === this.lastSongURL) {
this.startTrackingPosition();
} else {
// Reset position counter
this.startTrackingPosition(0);
this.lastSongURL = currentSong.url;
}
} catch (error: unknown) {
await this.forward(1);
if ((error as {statusCode: number}).statusCode === 410 && currentSong) {
const channelId = currentSong.addedInChannelId;
if (channelId) {
debug(`${currentSong.title} is unavailable`);
return;
}
}
throw error;
}
}
pause(): void {
if (this.status !== STATUS.PLAYING) {
throw new Error('Not currently playing.');
}
this.status = STATUS.PAUSED;
if (this.audioPlayer) {
this.audioPlayer.pause();
}
this.stopTrackingPosition();
}
async forward(skip: number): Promise<void> {
this.manualForward(skip);
console.log(this.getCurrent());
try {
if (this.getCurrent() && this.status !== STATUS.PAUSED) {
await this.play();
} else {
this.audioPlayer?.stop();
this.status = STATUS.IDLE;
const settings = await prisma.setting.findUnique({where: {guildId: this.guildId}});
if (!settings) {
throw new Error('Could not find settings for guild');
}
const {secondsToWaitAfterQueueEmpties} = settings;
if (secondsToWaitAfterQueueEmpties !== 0) {
this.disconnectTimer = setTimeout(() => {
// Make sure we are not accidentally playing
// when disconnecting
if (this.status === STATUS.IDLE) {
this.disconnect();
}
}, secondsToWaitAfterQueueEmpties * 1000);
}
}
} catch (error: unknown) {
this.queuePosition--;
throw error;
}
}
canGoForward(skip: number) {
return (this.queuePosition + skip - 1) < this.queue.length;
}
manualForward(skip: number): void {
if (this.canGoForward(skip)) {
this.queuePosition += skip;
this.positionInSeconds = 0;
this.stopTrackingPosition();
} else {
throw new Error('No songs in queue to forward to.');
}
}
canGoBack() {
return this.queuePosition - 1 >= 0;
}
async back(): Promise<void> {
if (this.canGoBack()) {
this.queuePosition--;
this.positionInSeconds = 0;
this.stopTrackingPosition();
if (this.status !== STATUS.PAUSED) {
await this.play();
}
} else {
throw new Error('No songs in queue to go back to.');
}
}
getCurrent(): QueuedSong | null {
if (this.queue[this.queuePosition]) {
return this.queue[this.queuePosition];
}
return null;
}
/**
* Returns queue, not including the current song.
* @returns {QueuedSong[]}
*/
getQueue(): QueuedSong[] {
return this.queue.slice(this.queuePosition + 1);
}
add(song: QueuedSong, {immediate = false} = {}): void {
if (song.playlist || !immediate) {
// Add to end of queue
this.queue.push(song);
} else {
// Add as the next song to be played
const insertAt = this.queuePosition + 1;
this.queue = [...this.queue.slice(0, insertAt), song, ...this.queue.slice(insertAt)];
}
}
shuffle(): void {
const shuffledSongs = shuffle(this.queue.slice(this.queuePosition + 1));
this.queue = [...this.queue.slice(0, this.queuePosition + 1), ...shuffledSongs];
}
clear(): void {
const newQueue = [];
// Don't clear curently playing song
const current = this.getCurrent();
if (current) {
newQueue.push(current);
}
this.queuePosition = 0;
this.queue = newQueue;
}
removeFromQueue(index: number, amount = 1): void {
this.queue.splice(this.queuePosition + index, amount);
}
removeCurrent(): void {
this.queue = [...this.queue.slice(0, this.queuePosition), ...this.queue.slice(this.queuePosition + 1)];
}
queueSize(): number {
return this.getQueue().length;
}
isQueueEmpty(): boolean {
return this.queueSize() === 0;
}
private getHashForCache(url: string): string {
return hasha(url);
}
private async getStream(url: string, options: {seek?: number} = {}): Promise<Readable> {
let ffmpegInput = '';
const ffmpegInputOptions: string[] = [];
let shouldCacheVideo = false;
let format: ytdl.videoFormat | undefined;
try {
ffmpegInput = await this.fileCache.getPathFor(this.getHashForCache(url));
if (options.seek) {
ffmpegInputOptions.push('-ss', options.seek.toString());
}
} catch {
// Not yet cached, must download
const info = await ytdl.getInfo(url);
const {formats} = info;
const filter = (format: ytdl.videoFormat): boolean => format.codecs === 'opus' && format.container === 'webm' && format.audioSampleRate !== undefined && parseInt(format.audioSampleRate, 10) === 48000;
format = formats.find(filter);
const nextBestFormat = (formats: ytdl.videoFormat[]): ytdl.videoFormat | undefined => {
if (formats[0].isLive) {
formats = formats.sort((a, b) => (b as unknown as {audioBitrate: number}).audioBitrate - (a as unknown as {audioBitrate: number}).audioBitrate); // Bad typings
return formats.find(format => [128, 127, 120, 96, 95, 94, 93].includes(parseInt(format.itag as unknown as string, 10))); // Bad typings
}
formats = formats
.filter(format => format.averageBitrate)
.sort((a, b) => {
if (a && b) {
return b.averageBitrate! - a.averageBitrate!;
}
return 0;
});
return formats.find(format => !format.bitrate) ?? formats[0];
};
if (!format) {
format = nextBestFormat(info.formats);
if (!format) {
// If still no format is found, throw
throw new Error('Can\'t find suitable format.');
}
}
ffmpegInput = format.url;
// Don't cache livestreams or long videos
const MAX_CACHE_LENGTH_SECONDS = 30 * 60; // 30 minutes
shouldCacheVideo = !info.player_response.videoDetails.isLiveContent && parseInt(info.videoDetails.lengthSeconds, 10) < MAX_CACHE_LENGTH_SECONDS && !options.seek;
ffmpegInputOptions.push(...[
'-reconnect',
'1',
'-reconnect_streamed',
'1',
'-reconnect_delay_max',
'5',
]);
if (options.seek) {
// Fudge seek position since FFMPEG doesn't do a great job
ffmpegInputOptions.push('-ss', (options.seek + 7).toString());
}
}
// Create stream and pipe to capacitor
return new Promise((resolve, reject) => {
const capacitor = new WriteStream();
// Cache video if necessary
if (shouldCacheVideo) {
const cacheStream = this.fileCache.createWriteStream(this.getHashForCache(url));
capacitor.createReadStream().pipe(cacheStream);
} else {
ffmpegInputOptions.push('-re');
}
const youtubeStream = ffmpeg(ffmpegInput)
.inputOptions(ffmpegInputOptions)
.noVideo()
.audioCodec('libopus')
.outputFormat('webm')
.on('error', error => {
console.error(error);
reject(error);
})
.on('start', command => {
debug(`Spawned ffmpeg with ${command as string}`);
});
youtubeStream.pipe(capacitor);
resolve(capacitor.createReadStream());
});
}
private startTrackingPosition(initalPosition?: number): void {
if (initalPosition !== undefined) {
this.positionInSeconds = initalPosition;
}
if (this.playPositionInterval) {
clearInterval(this.playPositionInterval);
}
this.playPositionInterval = setInterval(() => {
this.positionInSeconds++;
}, 1000);
}
private stopTrackingPosition(): void {
if (this.playPositionInterval) {
clearInterval(this.playPositionInterval);
}
}
private attachListeners(): void {
if (!this.voiceConnection) {
return;
}
if (this.voiceConnection.listeners(VoiceConnectionStatus.Disconnected).length === 0) {
this.voiceConnection.on(VoiceConnectionStatus.Disconnected, this.onVoiceConnectionDisconnect.bind(this));
}
if (!this.audioPlayer) {
return;
}
if (this.audioPlayer.listeners('stateChange').length === 0) {
this.audioPlayer.on('stateChange', this.onAudioPlayerStateChange.bind(this));
}
}
private onVoiceConnectionDisconnect(): void {
this.disconnect();
}
private async onAudioPlayerStateChange(_oldState: {status: AudioPlayerStatus}, newState: {status: AudioPlayerStatus}): Promise<void> {
// Automatically advance queued song at end
if (newState.status === AudioPlayerStatus.Idle && this.status === STATUS.PLAYING) {
await this.forward(1);
}
}
}