Add split command (#363)

Co-authored-by: Max Isom <hi@maxisom.me>
Co-authored-by: Max Isom <codetheweb@users.noreply.github.com>
This commit is contained in:
Hellyson Rodrigo Parteka 2022-03-09 23:47:52 -03:00 committed by GitHub
parent d438d46c09
commit 3dd1f21945
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 188 additions and 61 deletions

View file

@ -6,6 +6,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased]
### Added
- `/play` has a new `split` option that will split queued YouTube videos into chapters, if the video has them
- `/resume` command to resume playback
### Changed

View file

@ -24,7 +24,10 @@ export default class implements Command {
.setDescription('add track to the front of the queue'))
.addBooleanOption(option => option
.setName('shuffle')
.setDescription('shuffle the input if you\'re adding multiple tracks')))
.setDescription('shuffle the input if you\'re adding multiple tracks'))
.addBooleanOption(option => option
.setName('split')
.setDescription('if a track has chapters, split it')))
.addSubcommand(subcommand => subcommand
.setName('list')
.setDescription('list all favorites'))
@ -116,6 +119,7 @@ export default class implements Command {
query: favorite.query,
shuffleAdditions: interaction.options.getBoolean('shuffle') ?? false,
addToFrontOfQueue: interaction.options.getBoolean('immediate') ?? false,
shouldSplitChapters: interaction.options.getBoolean('split') ?? false,
});
}

View file

@ -26,7 +26,10 @@ export default class implements Command {
.setDescription('add track to the front of the queue'))
.addBooleanOption(option => option
.setName('shuffle')
.setDescription('shuffle the input if you\'re adding multiple tracks'));
.setDescription('shuffle the input if you\'re adding multiple tracks'))
.addBooleanOption(option => option
.setName('split')
.setDescription('if a track has chapters, split it'));
public requiresVC = true;
@ -49,6 +52,7 @@ export default class implements Command {
query: query.trim(),
addToFrontOfQueue: interaction.options.getBoolean('immediate') ?? false,
shuffleAdditions: interaction.options.getBoolean('shuffle') ?? false,
shouldSplitChapters: interaction.options.getBoolean('split') ?? false,
});
}

View file

@ -25,7 +25,7 @@ export default class implements Command {
}
public async execute(interaction: CommandInteraction): Promise<void> {
const numToSkip = interaction.options.getInteger('skip') ?? 1;
const numToSkip = interaction.options.getInteger('number') ?? 1;
if (numToSkip < 1) {
throw new Error('invalid number of songs to skip');

View file

@ -1,3 +1,4 @@
/* eslint-disable complexity */
import {CommandInteraction, GuildMember} from 'discord.js';
import {inject, injectable} from 'inversify';
import {Except} from 'type-fest';
@ -18,11 +19,13 @@ export default class AddQueryToQueue {
query,
addToFrontOfQueue,
shuffleAdditions,
shouldSplitChapters,
interaction,
}: {
query: string;
addToFrontOfQueue: boolean;
shuffleAdditions: boolean;
shouldSplitChapters: boolean;
interaction: CommandInteraction;
}): Promise<void> {
const guildId = interaction.guild!.id;
@ -60,18 +63,18 @@ export default class AddQueryToQueue {
// YouTube source
if (url.searchParams.get('list')) {
// YouTube playlist
newSongs.push(...await this.getSongs.youtubePlaylist(url.searchParams.get('list')!));
newSongs.push(...await this.getSongs.youtubePlaylist(url.searchParams.get('list')!, shouldSplitChapters));
} else {
const song = await this.getSongs.youtubeVideo(url.href);
const songs = await this.getSongs.youtubeVideo(url.href, shouldSplitChapters);
if (song) {
newSongs.push(song);
if (songs) {
newSongs.push(...songs);
} else {
throw new Error('that doesn\'t exist');
}
}
} else if (url.protocol === 'spotify:' || url.host === 'open.spotify.com') {
const [convertedSongs, nSongsNotFound, totalSongs] = await this.getSongs.spotifySource(query, playlistLimit);
const [convertedSongs, nSongsNotFound, totalSongs] = await this.getSongs.spotifySource(query, playlistLimit, shouldSplitChapters);
if (totalSongs > playlistLimit) {
extraMsg = `a random sample of ${playlistLimit} songs was taken`;
@ -93,10 +96,10 @@ export default class AddQueryToQueue {
}
} catch (_: unknown) {
// Not a URL, must search YouTube
const song = await this.getSongs.youtubeVideoSearch(query);
const songs = await this.getSongs.youtubeVideoSearch(query, shouldSplitChapters);
if (song) {
newSongs.push(song);
if (songs) {
newSongs.push(...songs);
} else {
throw new Error('that doesn\'t exist');
}

View file

@ -5,7 +5,7 @@ import got from 'got';
import ytsr, {Video} from 'ytsr';
import spotifyURI from 'spotify-uri';
import Spotify from 'spotify-web-api-node';
import YouTube, {YoutubePlaylistItem} from 'youtube.ts';
import YouTube, {YoutubePlaylistItem, YoutubeVideo} from 'youtube.ts';
import PQueue from 'p-queue';
import shuffle from 'array-shuffle';
import {Except} from 'type-fest';
@ -16,9 +16,18 @@ import ThirdParty from './third-party.js';
import Config from './config.js';
import KeyValueCacheProvider from './key-value-cache.js';
import {ONE_HOUR_IN_SECONDS, ONE_MINUTE_IN_SECONDS} from '../utils/constants.js';
import {parseTime} from '../utils/time.js';
type SongMetadata = Except<QueuedSong, 'addedInChannelId' | 'requestedBy'>;
interface VideoDetailsResponse {
id: string;
contentDetails: {
videoId: string;
duration: string;
};
}
@injectable()
export default class {
private readonly youtube: YouTube;
@ -40,7 +49,7 @@ export default class {
this.ytsrQueue = new PQueue({concurrency: 4});
}
async youtubeVideoSearch(query: string): Promise<SongMetadata> {
async youtubeVideoSearch(query: string, shouldSplitChapters: boolean): Promise<SongMetadata[]> {
const {items} = await this.ytsrQueue.add(async () => this.cache.wrap(
ytsr,
query,
@ -65,11 +74,11 @@ export default class {
throw new Error('No video found.');
}
return this.youtubeVideo(firstVideo.id);
return this.youtubeVideo(firstVideo.id, shouldSplitChapters);
}
async youtubeVideo(url: string): Promise<SongMetadata> {
const videoDetails = await this.cache.wrap(
async youtubeVideo(url: string, shouldSplitChapters: boolean): Promise<SongMetadata[]> {
const video = await this.cache.wrap(
this.youtube.videos.get,
cleanUrl(url),
{
@ -77,18 +86,10 @@ export default class {
},
);
return {
title: videoDetails.snippet.title,
artist: videoDetails.snippet.channelTitle,
length: toSeconds(parse(videoDetails.contentDetails.duration)),
url: videoDetails.id,
playlist: null,
isLive: videoDetails.snippet.liveBroadcastContent === 'live',
thumbnailUrl: videoDetails.snippet.thumbnails.medium.url,
};
return this.getMetadataFromVideo({video, shouldSplitChapters});
}
async youtubePlaylist(listId: string): Promise<SongMetadata[]> {
async youtubePlaylist(listId: string, shouldSplitChapters: boolean): Promise<SongMetadata[]> {
// YouTube playlist
const playlist = await this.cache.wrap(
this.youtube.playlists.get,
@ -98,14 +99,6 @@ export default class {
},
);
interface VideoDetailsResponse {
id: string;
contentDetails: {
videoId: string;
duration: string;
};
}
const playlistVideos: YoutubePlaylistItem[] = [];
const videoDetailsPromises: Array<Promise<void>> = [];
const videoDetails: VideoDetailsResponse[] = [];
@ -161,17 +154,12 @@ export default class {
for (const video of playlistVideos) {
try {
const length = toSeconds(parse(videoDetails.find((i: {id: string}) => i.id === video.contentDetails.videoId)!.contentDetails.duration));
songsToReturn.push({
title: video.snippet.title,
artist: video.snippet.channelTitle,
length,
url: video.contentDetails.videoId,
playlist: queuedPlaylist,
isLive: false,
thumbnailUrl: video.snippet.thumbnails.medium.url,
});
songsToReturn.push(...this.getMetadataFromVideo({
video,
queuedPlaylist,
videoDetails: videoDetails.find((i: {id: string}) => i.id === video.contentDetails.videoId),
shouldSplitChapters,
}));
} catch (_: unknown) {
// Private and deleted videos are sometimes in playlists, duration of these is not returned and they should not be added to the queue.
}
@ -180,7 +168,7 @@ export default class {
return songsToReturn;
}
async spotifySource(url: string, playlistLimit: number): Promise<[SongMetadata[], number, number]> {
async spotifySource(url: string, playlistLimit: number, shouldSplitChapters: boolean): Promise<[SongMetadata[], number, number]> {
const parsed = spotifyURI.parse(url);
let tracks: SpotifyApi.TrackObjectSimplified[] = [];
@ -253,17 +241,19 @@ export default class {
tracks = shuffled.slice(0, playlistLimit);
}
const searchResults = await Promise.allSettled(tracks.map(async track => this.spotifyToYouTube(track)));
const searchResults = await Promise.allSettled(tracks.map(async track => this.spotifyToYouTube(track, shouldSplitChapters)));
let nSongsNotFound = 0;
// Count songs that couldn't be found
const songs: SongMetadata[] = searchResults.reduce((accum: SongMetadata[], result) => {
if (result.status === 'fulfilled') {
for (const v of result.value) {
accum.push({
...result.value,
...v,
...(playlist ? {playlist} : {}),
});
}
} else {
nSongsNotFound++;
}
@ -274,7 +264,110 @@ export default class {
return [songs, nSongsNotFound, originalNSongs];
}
private async spotifyToYouTube(track: SpotifyApi.TrackObjectSimplified): Promise<SongMetadata> {
return this.youtubeVideoSearch(`"${track.name}" "${track.artists[0].name}"`);
private async spotifyToYouTube(track: SpotifyApi.TrackObjectSimplified, shouldSplitChapters: boolean): Promise<SongMetadata[]> {
return this.youtubeVideoSearch(`"${track.name}" "${track.artists[0].name}"`, shouldSplitChapters);
}
// TODO: we should convert YouTube videos (from both single videos and playlists) to an intermediate representation so we don't have to check if it's from a playlist
private getMetadataFromVideo({
video,
queuedPlaylist,
videoDetails,
shouldSplitChapters,
}: {
video: YoutubeVideo | YoutubePlaylistItem;
queuedPlaylist?: QueuedPlaylist;
videoDetails?: VideoDetailsResponse;
shouldSplitChapters?: boolean;
}): SongMetadata[] {
let url: string;
let videoDurationSeconds: number;
// Dirty hack
if (queuedPlaylist) {
// Is playlist item
video = video as YoutubePlaylistItem;
url = video.contentDetails.videoId;
videoDurationSeconds = toSeconds(parse(videoDetails!.contentDetails.duration));
} else {
video = video as YoutubeVideo;
videoDurationSeconds = toSeconds(parse(video.contentDetails.duration));
url = video.id;
}
const base: SongMetadata = {
title: video.snippet.title,
artist: video.snippet.channelTitle,
length: videoDurationSeconds,
offset: 0,
url,
playlist: queuedPlaylist ?? null,
isLive: false,
thumbnailUrl: video.snippet.thumbnails.medium.url,
};
if (!shouldSplitChapters) {
return [base];
}
const chapters = this.parseChaptersFromDescription(video.snippet.description, videoDurationSeconds);
if (!chapters) {
return [base];
}
const tracks: SongMetadata[] = [];
for (const [label, {offset, length}] of chapters) {
tracks.push({
...base,
offset,
length,
title: `${label} (${base.title})`,
});
}
return tracks;
}
private parseChaptersFromDescription(description: string, videoDurationSeconds: number) {
const map = new Map<string, {offset: number; length: number}>();
let foundFirstTimestamp = false;
const foundTimestamps: Array<{name: string; offset: number}> = [];
for (const line of description.split('\n')) {
const timestamps = Array.from(line.matchAll(/(?:\d+:)+\d+/g));
if (timestamps?.length !== 1) {
continue;
}
if (!foundFirstTimestamp) {
if (/0{1,2}:00/.test(timestamps[0][0])) {
foundFirstTimestamp = true;
} else {
continue;
}
}
const timestamp = timestamps[0][0];
const seconds = parseTime(timestamp);
const chapterName = line.split(timestamp)[1].trim();
foundTimestamps.push({name: chapterName, offset: seconds});
}
for (const [i, {name, offset}] of foundTimestamps.entries()) {
map.set(name, {
offset,
length: i === foundTimestamps.length - 1
? videoDurationSeconds - offset
: foundTimestamps[i + 1].offset - offset,
});
}
if (!map.size) {
return null;
}
return map;
}
}

View file

@ -20,6 +20,7 @@ export interface QueuedSong {
artist: string;
url: string;
length: number;
offset: number;
playlist: QueuedPlaylist | null;
isLive: boolean;
addedInChannelId: Snowflake;
@ -98,7 +99,14 @@ export default class {
throw new Error('Seek position is outside the range of the song.');
}
const stream = await this.getStream(currentSong.url, {seek: positionSeconds});
let realPositionSeconds = positionSeconds;
let to: number | undefined;
if (currentSong.offset !== undefined) {
realPositionSeconds += currentSong.offset;
to = currentSong.length + currentSong.offset;
}
const stream = await this.getStream(currentSong.url, {seek: realPositionSeconds, to});
this.audioPlayer = createAudioPlayer({
behaviors: {
// Needs to be somewhat high for livestreams
@ -156,7 +164,14 @@ export default class {
}
try {
const stream = await this.getStream(currentSong.url);
let positionSeconds: number | undefined;
let to: number | undefined;
if (currentSong.offset !== undefined) {
positionSeconds = currentSong.offset;
to = currentSong.length + currentSong.offset;
}
const stream = await this.getStream(currentSong.url, {seek: positionSeconds, to});
this.audioPlayer = createAudioPlayer({
behaviors: {
// Needs to be somewhat high for livestreams
@ -350,7 +365,7 @@ export default class {
return hasha(url);
}
private async getStream(url: string, options: {seek?: number} = {}): Promise<Readable> {
private async getStream(url: string, options: {seek?: number; to?: number} = {}): Promise<Readable> {
let ffmpegInput = '';
const ffmpegInputOptions: string[] = [];
let shouldCacheVideo = false;
@ -363,6 +378,10 @@ export default class {
if (options.seek) {
ffmpegInputOptions.push('-ss', options.seek.toString());
}
if (options.to) {
ffmpegInputOptions.push('-to', options.to.toString());
}
} catch {
// Not yet cached, must download
const info = await ytdl.getInfo(url);
@ -405,7 +424,7 @@ export default class {
// 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;
shouldCacheVideo = !info.player_response.videoDetails.isLiveContent && parseInt(info.videoDetails.lengthSeconds, 10) < MAX_CACHE_LENGTH_SECONDS && !options.seek && !options.to;
ffmpegInputOptions.push(...[
'-reconnect',
@ -417,8 +436,11 @@ export default class {
]);
if (options.seek) {
// Fudge seek position since FFMPEG doesn't do a great job
ffmpegInputOptions.push('-ss', (options.seek + 7).toString());
ffmpegInputOptions.push('-ss', options.seek.toString());
}
if (options.to) {
ffmpegInputOptions.push('-to', options.to.toString());
}
}

View file

@ -13,13 +13,13 @@ const getMaxSongTitleLength = (title: string) => {
return nonASCII.test(title) ? 28 : 48;
};
const getSongTitle = ({title, url}: QueuedSong, shouldTruncate = false) => {
const getSongTitle = ({title, url, offset}: QueuedSong, shouldTruncate = false) => {
const cleanSongTitle = title.replace(/\[.*\]/, '').trim();
const songTitle = shouldTruncate ? truncate(cleanSongTitle, getMaxSongTitleLength(cleanSongTitle)) : cleanSongTitle;
const youtubeId = url.length === 11 ? url : getYouTubeID(url) ?? '';
return `[${songTitle}](https://www.youtube.com/watch?v=${youtubeId})`;
return `[${songTitle}](https://www.youtube.com/watch?v=${youtubeId}${offset === 0 ? '' : '&t=' + String(offset)})`;
};
const getQueueInfo = (player: Player) => {