upd: add modplayer

packages/backend/src/server/web/views/base.pug

@@ -41,6 +41,7 @@ html
 		//- https://github.com/misskey-dev/misskey/issues/9842
 		link(rel='stylesheet' href='/assets/phosphor-icons/bold/style.css')
 		link(rel='modulepreload' href=`/vite/${clientEntry.file}`)
+		script(src='/client-assets/libopenmpt.js')
 
 		if !config.clientManifestExists
 				script(type="module" src="/vite/@vite/client")
@@ -70,6 +71,7 @@ html
 		script.
 			var VERSION = "#{version}";
 			var CLIENT_ENTRY = "#{clientEntry.file}";
+			window.libopenmpt = window.Module;
 
 		script
 			include ../boot.js

packages/frontend/src/components/MkMediaList.vue

@@ -21,6 +21,7 @@ SPDX-License-Identifier: AGPL-3.0-only
 			<template v-for="media in mediaList.filter(media => previewable(media))">
 				<XVideo v-if="media.type.startsWith('video')" :key="`video:${media.id}`" :class="$style.media" :video="media"/>
 				<XImage v-else-if="media.type.startsWith('image')" :key="`image:${media.id}`" :class="$style.media" class="image" :data-id="media.id" :image="media" :raw="raw"/>
+				<XModPlayer v-else-if="isModule(media)" :key="media.id" :module="media"/>
 			</template>
 		</div>
 	</div>
@@ -71,8 +72,9 @@ import 'photoswipe/style.css';
 import XBanner from '@/components/MkMediaBanner.vue';
 import XImage from '@/components/MkMediaImage.vue';
 import XVideo from '@/components/MkMediaVideo.vue';
+import XModPlayer from '@/components/MkModPlayer.vue';
 import * as os from '@/os.js';
-import { FILE_TYPE_BROWSERSAFE } from '@/const';
+import { FILE_TYPE_BROWSERSAFE, FILE_EXT_TRACKER_MODULES, FILE_TYPE_TRACKER_MODULES } from '@/const.js';
 import { defaultStore } from '@/store.js';
 import { getScrollContainer, getBodyScrollHeight } from '@/scripts/scroll.js';
 
@@ -146,6 +148,12 @@ async function calcAspectRatio() {
 	gallery.value.style.aspectRatio = 'initial';
 }
 
+const isModule = (file: Misskey.entities.DriveFile): boolean => {
+	return FILE_TYPE_TRACKER_MODULES.includes(file.type) || FILE_EXT_TRACKER_MODULES.some((ext) => {
+		return (file.name.toLowerCase().endsWith('.' + ext) || file.name.toLowerCase().endsWith('.' + ext + '.unknown'));
+	});
+};
+
 onMounted(() => {
 	calcAspectRatio();
 
@@ -255,6 +263,7 @@ onUnmounted(() => {
 const previewable = (file: Misskey.entities.DriveFile): boolean => {
 	if (file.type === 'image/svg+xml') return true; // svgのwebpublic/thumbnailはpngなのでtrue
 	// FILE_TYPE_BROWSERSAFEに適合しないものはブラウザで表示するのに不適切
+	if (isModule(file)) return true;
 	return (file.type.startsWith('video') || file.type.startsWith('image')) && FILE_TYPE_BROWSERSAFE.includes(file.type);
 };
 </script>

packages/frontend/src/components/MkModPlayer.vue

@@ -0,0 +1,423 @@
+<template>
+<div v-if="hide" class="mod-player-disabled" @click="toggleVisible()">
+	<div>
+		<b><i class="fas fa-exlamation-triangle"></i> {{ i18n.ts.sensitive }}</b>
+		<span>{{ i18n.ts.clickToShow }}</span>
+	</div>
+</div>
+
+<div v-else class="mod-player-enabled">
+	<div class="pattern-display">
+		<canvas ref="displayCanvas" class="pattern-canvas"></canvas>
+	</div>
+	<div class="controls">
+		<button class="play" @click="playPause()">
+			<i v-if="playing" class="ph-pause ph-bold ph-lg"></i>
+			<i v-else class="ph-play ph-bold ph-lg"></i>
+		</button>
+		<button class="stop" @click="stop()">
+			<i class="ph-stop ph-bold ph-lg"></i>
+		</button>
+		<input ref="progress" v-model="position" class="progress" type="range" min="0" max="1" step="0.1" @mousedown="initSeek()" @mouseup="performSeek()"/>
+		<input v-model="player.context.gain.value" type="range" min="0" max="1" step="0.1"/>
+		<a class="download" :title="i18n.ts.download" :href="module.url" target="_blank">
+			<i class="ph-download ph-bold ph-lg"></i>
+		</a>
+	</div>
+	<i class="hide ph-eye-slash ph-bold ph-lg" @click="toggleVisible()"></i>
+</div>
+</template>
+
+<script lang="ts" setup>
+import { ref, nextTick } from 'vue';
+import * as Misskey from 'misskey-js';
+import { i18n } from '@/i18n.js';
+import { defaultStore } from '@/store.js';
+import { ChiptuneJsPlayer, ChiptuneJsConfig } from '@/scripts/chiptune2.js';
+
+const CHAR_WIDTH = 6;
+const CHAR_HEIGHT = 12;
+const ROW_OFFSET_Y = 10;
+
+const colours = {
+	background: '#000000',
+	default: {
+		active: '#ffffff',
+		inactive: '#808080',
+	},
+	quarter: {
+		active: '#ffff00',
+		inactive: '#ffe135',
+	},
+	instr: {
+		active: '#80e0ff',
+		inactive: '#0099cc',
+	},
+	volume: {
+		active: '#80ff80',
+		inactive: '#008000',
+	},
+	fx: {
+		active: '#ff80e0',
+		inactive: '#800060',
+	},
+	operant: {
+		active: '#ffe080',
+		inactive: '#806000',
+	},
+};
+
+const props = defineProps<{
+	module: Misskey.entities.DriveFile
+}>();
+
+const isSensitive = $computed(() => { return props.module.isSensitive; });
+const url = $computed(() => { return props.module.url; });
+let hide = ref((defaultStore.state.nsfw === 'force') ? true : isSensitive && (defaultStore.state.nsfw !== 'ignore'));
+let playing = ref(false);
+let displayCanvas = ref<HTMLCanvasElement>();
+let progress = ref<HTMLProgressElement>();
+let position = ref(0);
+const player = ref(new ChiptuneJsPlayer(new ChiptuneJsConfig()));
+
+const rowBuffer = 24;
+let buffer = null;
+let isSeeking = false;
+
+player.value.load(url).then((result) => {
+	buffer = result;
+	try {
+		player.value.play(buffer);
+		progress.value!.max = player.value.duration();
+		display();
+	} catch (e) {
+		console.warn(e);
+	}
+	player.value.stop();
+}).catch((error) => {
+	console.error(error);
+});
+
+function playPause() {
+	player.value.addHandler('onRowChange', () => {
+		progress.value!.max = player.value.duration();
+		if (!isSeeking) {
+			position.value = player.value.position() % player.value.duration();
+		}
+		display();
+	});
+
+	player.value.addHandler('onEnded', () => {
+		stop();
+	});
+
+	if (player.value.currentPlayingNode === null) {
+		player.value.play(buffer);
+		player.value.seek(position.value);
+		playing.value = true;
+	} else {
+		player.value.togglePause();
+		playing.value = !player.value.currentPlayingNode.paused;
+	}
+}
+
+function stop(noDisplayUpdate = false) {
+	player.value.stop();
+	playing.value = false;
+	if (!noDisplayUpdate) {
+		try {
+			player.value.play(buffer);
+			display();
+		} catch (e) {
+			console.warn(e);
+		}
+	}
+	player.value.stop();
+	position.value = 0;
+	player.value.handlers = [];
+}
+
+function initSeek() {
+	isSeeking = true;
+}
+
+function performSeek() {
+	const noNode = !player.value.currentPlayingNode;
+	if (noNode) {
+		player.value.play(buffer);
+	}
+	player.value.seek(position.value);
+	display();
+	if (noNode) {
+		player.value.stop();
+	}
+	isSeeking = false;
+}
+
+function toggleVisible() {
+	hide.value = !hide.value;
+	nextTick(() => { stop(hide.value); });
+}
+
+function display() {
+	if (!displayCanvas.value) {
+		stop();
+		return;
+	}
+
+	const canvas = displayCanvas.value;
+
+	const pattern = player.value.getPattern();
+	const row = player.value.getRow();
+	let nbChannels = 0;
+	if (player.value.currentPlayingNode) {
+		nbChannels = player.value.currentPlayingNode.nbChannels;
+	}
+	if (canvas.width !== 12 + 84 * nbChannels + 2) {
+		canvas.width = 12 + 84 * nbChannels + 2;
+		canvas.height = 12 * rowBuffer;
+	}
+	const nbRows = player.value.getPatternNumRows(pattern);
+	const ctx = canvas.getContext('2d') as CanvasRenderingContext2D;
+	ctx.font = '10px monospace';
+	ctx.fillStyle = colours.background;
+	ctx.fillRect(0, 0, canvas.width, canvas.height);
+	ctx.fillStyle = colours.default.inactive;
+	for (let rowOffset = 0; rowOffset < rowBuffer; rowOffset++) {
+		const rowToDraw = row - rowBuffer / 2 + rowOffset;
+		if (rowToDraw >= 0 && rowToDraw < nbRows) {
+			const active = (rowToDraw === row) ? 'active' : 'inactive';
+			let rowText = parseInt(rowToDraw).toString(16);
+			if (rowText.length === 1) {
+				rowText = '0' + rowText;
+			}
+			ctx.fillStyle = colours.default[active];
+			if (rowToDraw % 4 === 0) {
+				ctx.fillStyle = colours.quarter[active];
+			}
+			ctx.fillText(rowText, 0, 10 + rowOffset * 12);
+			for (let channel = 0; channel < nbChannels; channel++) {
+				const part = player.value.getPatternRowChannel(pattern, rowToDraw, channel);
+				const baseOffset = (2 + (part.length + 1) * channel) * CHAR_WIDTH;
+				const baseRowOffset = ROW_OFFSET_Y + rowOffset * CHAR_HEIGHT;
+
+				ctx.fillStyle = colours.default[active];
+				ctx.fillText('|', baseOffset, baseRowOffset);
+
+				const note = part.substring(0, 3);
+				ctx.fillStyle = colours.default[active];
+				ctx.fillText(note, baseOffset + CHAR_WIDTH, baseRowOffset);
+
+				const instr = part.substring(4, 6);
+				ctx.fillStyle = colours.instr[active];
+				ctx.fillText(instr, baseOffset + CHAR_WIDTH * 5, baseRowOffset);
+				
+				const volume = part.substring(6, 9);
+				ctx.fillStyle = colours.volume[active];
+				ctx.fillText(volume, baseOffset + CHAR_WIDTH * 7, baseRowOffset);
+
+				const fx = part.substring(10, 11);
+				ctx.fillStyle = colours.fx[active];
+				ctx.fillText(fx, baseOffset + CHAR_WIDTH * 11, baseRowOffset);
+
+				const op = part.substring(11, 13);
+				ctx.fillStyle = colours.operant[active];
+				ctx.fillText(op, baseOffset + CHAR_WIDTH * 12, baseRowOffset);
+			}
+		}
+	}
+}
+
+</script>
+
+<style lang="scss" scoped>
+
+.hide {
+	border-radius: var(--radius-sm) !important;
+	background-color: black !important;
+	color: var(--accentLighten) !important;
+	font-size: 12px !important;
+}
+
+.mod-player-enabled {
+	position: relative;
+	overflow: hidden;
+	display: flex;
+	flex-direction: column;
+
+	> i {
+		display: block;
+		position: absolute;
+		border-radius: var(--radius-sm);
+		background-color: var(--fg);
+		color: var(--accentLighten);
+		font-size: 14px;
+		opacity: .5;
+		padding: 3px 6px;
+		text-align: center;
+		cursor: pointer;
+		top: 12px;
+		right: 12px;
+	}
+
+	> .pattern-display {
+		width: 100%;
+		height: 100%;
+		overflow-x: scroll;
+		overflow-y: hidden;
+		background-color: black;
+		text-align: center;
+		.pattern-canvas {
+			background-color: black;
+			height: 100%;
+		}
+	}
+
+	> .controls {
+		display: flex;
+		width: 100%;
+		background-color: var(--bg);
+
+		> * {
+			padding: 4px 8px;
+		}
+
+		> button, a {
+			border: none;
+			background-color: transparent;
+			color: var(--accent);
+			cursor: pointer;
+
+			&:hover {
+				background-color: var(--fg);
+			}
+		}
+
+		> input[type=range] {
+			height: 21px;
+			-webkit-appearance: none;
+			width: 90px;
+			padding: 0;
+			margin: 4px 8px;
+			overflow-x: hidden;
+
+			&:focus {
+				outline: none;
+
+				&::-webkit-slider-runnable-track {
+					background: var(--bg);
+				}
+
+				&::-ms-fill-lower, &::-ms-fill-upper {
+					background: var(--bg);
+				}
+			}
+
+			&::-webkit-slider-runnable-track {
+				width: 100%;
+				height: 100%;
+				cursor: pointer;
+				border-radius: 0;
+				animate: 0.2s;
+				background: var(--bg);
+				border: 1px solid var(--fg);
+				overflow-x: hidden;
+			}
+
+			&::-webkit-slider-thumb {
+				border: none;
+				height: 100%;
+				width: 14px;
+				border-radius: 0;
+				background: var(--accentLighten);
+				cursor: pointer;
+				-webkit-appearance: none;
+				box-shadow: calc(-100vw - 14px) 0 0 100vw var(--accent);
+				clip-path: polygon(1px 0, 100% 0, 100% 100%, 1px 100%, 1px calc(50% + 10.5px), -100vw calc(50% + 10.5px), -100vw calc(50% - 10.5px), 0 calc(50% - 10.5px));
+				z-index: 1;
+			}
+
+			&::-moz-range-track {
+				width: 100%;
+				height: 100%;
+				cursor: pointer;
+				border-radius: 0;
+				animate: 0.2s;
+				background: var(--bg);
+				border: 1px solid var(--fg);
+			}
+
+			&::-moz-range-progress {
+				cursor: pointer;
+				height: 100%;
+				background: var(--accent);
+			}
+
+			&::-moz-range-thumb {
+				border: none;
+				height: 100%;
+				border-radius: 0;
+				width: 14px;
+				background: var(--accentLighten);
+				cursor: pointer;
+			}
+
+			&::-ms-track {
+				width: 100%;
+				height: 100%;
+				cursor: pointer;
+				border-radius: 0;
+				animate: 0.2s;
+				background: transparent;
+				border-color: transparent;
+				color: transparent;
+			}
+
+			&::-ms-fill-lower {
+				background: var(--accent);
+				border: 1px solid var(--fg);
+				border-radius: 0;
+			}
+
+			&::-ms-fill-upper {
+				background: var(--bg);
+				border: 1px solid var(--fg);
+				border-radius: 0;
+			}
+
+			&::-ms-thumb {
+				margin-top: 1px;
+				border: none;
+				height: 100%;
+				width: 14px;
+				border-radius: 0;
+				background: var(--accentLighten);
+				cursor: pointer;
+			}
+
+			&.progress {
+				flex-grow: 1;
+				min-width: 0;
+			}
+		}
+	}
+}
+
+.mod-player-disabled {
+	display: flex;
+	justify-content: center;
+	align-items: center;
+	background: #111;
+	color: #fff;
+
+	> div {
+		display: table-cell;
+		text-align: center;
+		font-size: 12px;
+
+		> b {
+			display: block;
+		}
+	}
+}
+</style>

packages/frontend/src/const.ts

@@ -17,6 +17,7 @@ export const FILE_TYPE_BROWSERSAFE = [
 	'image/bmp',
 	'image/tiff',
 	'image/x-icon',
+	'image/jxl',
 
 	// OggS
 	'audio/opus',
@@ -48,6 +49,56 @@ export const FILE_TYPE_BROWSERSAFE = [
 	'audio/x-flac',
 	'audio/vnd.wave',
 ];
+
+export const FILE_TYPE_TRACKER_MODULES = [
+	'audio/mod',
+	'audio/x-mod',
+	'audio/s3m',
+	'audio/x-s3m',
+	'audio/xm',
+	'audio/x-xm',
+	'audio/it',
+	'audio/x-it',
+];
+
+export const FILE_EXT_TRACKER_MODULES = [
+	'mod',
+	's3m',
+	'xm',
+	'it',
+	'mptm',
+	'stm',
+	'nst',
+	'm15',
+	'stk',
+	'wow',
+	'ult',
+	'669',
+	'mtm',
+	'med',
+	'far',
+	'mdl',
+	'ams',
+	'dsm',
+	'amf',
+	'okt',
+	'dmf',
+	'ptm',
+	'psm',
+	'mt2',
+	'dbm',
+	'digi',
+	'imf',
+	'j2b',
+	'gdm',
+	'umx',
+	'plm',
+	'mo3',
+	'xpk',
+	'ppm',
+	'mmcmp',
+];
+
 /*
 https://github.com/sindresorhus/file-type/blob/main/supported.js
 https://github.com/sindresorhus/file-type/blob/main/core.js

packages/frontend/src/scripts/chiptune2.ts

@@ -0,0 +1,266 @@
+/* global libopenmpt UTF8ToString writeAsciiToMemory */
+
+const ChiptuneAudioContext = window.AudioContext || window.webkitAudioContext;
+
+export function ChiptuneJsConfig (repeatCount: number, context: AudioContext) {
+	this.repeatCount = repeatCount;
+	this.context = context;
+}
+
+ChiptuneJsConfig.prototype.constructor = ChiptuneJsConfig;
+
+export function ChiptuneJsPlayer (config: object) {
+	this.config = config;
+	this.audioContext = config.context || new ChiptuneAudioContext();
+	this.context = this.audioContext.createGain();
+	this.currentPlayingNode = null;
+	this.handlers = [];
+	this.touchLocked = true;
+	this.volume = 1;
+}
+
+ChiptuneJsPlayer.prototype.constructor = ChiptuneJsPlayer;
+
+ChiptuneJsPlayer.prototype.fireEvent = function (eventName: string, response) {
+	const handlers = this.handlers;
+	if (handlers.length > 0) {
+		for(const handler of handlers) {
+			if (handler.eventName === eventName) {
+				handler.handler(response);
+			}
+		}
+	}
+};
+
+ChiptuneJsPlayer.prototype.addHandler = function (eventName: string, handler: Function) {
+	this.handlers.push({ eventName, handler });
+};
+
+ChiptuneJsPlayer.prototype.onEnded = function (handler: Function) {
+	this.addHandler('onEnded', handler);
+};
+
+ChiptuneJsPlayer.prototype.onError = function (handler: Function) {
+	this.addHandler('onError', handler);
+};
+
+ChiptuneJsPlayer.prototype.duration = function () {
+	return libopenmpt._openmpt_module_get_duration_seconds(this.currentPlayingNode.modulePtr);
+};
+
+ChiptuneJsPlayer.prototype.position = function () {
+	return libopenmpt._openmpt_module_get_position_seconds(this.currentPlayingNode.modulePtr);
+};
+
+ChiptuneJsPlayer.prototype.seek = function (position: number) {
+	if (this.currentPlayingNode) {
+		libopenmpt._openmpt_module_set_position_seconds(this.currentPlayingNode.modulePtr, position);
+	}
+};
+
+ChiptuneJsPlayer.prototype.metadata = function () {
+	const data = {};
+	const keys = UTF8ToString(libopenmpt._openmpt_module_get_metadata_keys(this.currentPlayingNode.modulePtr)).split(';');
+	let keyNameBuffer = 0;
+	for (const key of keys) {
+		keyNameBuffer = libopenmpt._malloc(key.length + 1);
+		writeAsciiToMemory(key, keyNameBuffer);
+		data[key] = UTF8ToString(libopenmpt._openmpt_module_get_metadata(this.currentPlayingNode.modulePtr, keyNameBuffer));
+		libopenmpt._free(keyNameBuffer);
+	}
+	return data;
+};
+
+ChiptuneJsPlayer.prototype.unlock = function () {
+	const context = this.audioContext;
+	const buffer = context.createBuffer(1, 1, 22050);
+	const unlockSource = context.createBufferSource();
+	unlockSource.buffer = buffer;
+	unlockSource.connect(this.context);
+	this.context.connect(context.destination);
+	unlockSource.start(0);
+	this.touchLocked = false;
+};
+
+ChiptuneJsPlayer.prototype.load = function (input) {
+	return new Promise((resolve, reject) => {
+		if(this.touchLocked) {
+			this.unlock();
+		}
+		const player = this;
+		if (input instanceof File) {
+			const reader = new FileReader();
+			reader.onload = () => {
+				resolve(reader.result);
+			};
+			reader.readAsArrayBuffer(input);
+		} else {
+			window.fetch(input).then((response) => {
+				response.arrayBuffer().then((arrayBuffer) => {
+					resolve(arrayBuffer);
+				}).catch((error) => {
+					reject(error);
+				});
+			}).catch((error) => {
+				reject(error);
+			});
+		}
+	});
+};
+
+ChiptuneJsPlayer.prototype.play = function (buffer: ArrayBuffer) {
+	this.unlock();
+	this.stop();
+	const processNode = this.createLibopenmptNode(buffer, this.buffer);
+	if (processNode === null) {
+		return;
+	}
+	libopenmpt._openmpt_module_set_repeat_count(processNode.modulePtr, this.config.repeatCount || 0);
+	this.currentPlayingNode = processNode;
+	processNode.connect(this.context);
+	this.context.connect(this.audioContext.destination);
+};
+
+ChiptuneJsPlayer.prototype.stop = function () {
+	if (this.currentPlayingNode != null) {
+		this.currentPlayingNode.disconnect();
+		this.currentPlayingNode.cleanup();
+		this.currentPlayingNode = null;
+	}
+};
+
+ChiptuneJsPlayer.prototype.togglePause = function () {
+	if (this.currentPlayingNode != null) {
+		this.currentPlayingNode.togglePause();
+	}
+};
+
+ChiptuneJsPlayer.prototype.getPattern = function () {
+	if (this.currentPlayingNode && this.currentPlayingNode.modulePtr) {
+		return libopenmpt._openmpt_module_get_current_pattern(this.currentPlayingNode.modulePtr);
+	}
+	return 0;
+};
+
+ChiptuneJsPlayer.prototype.getRow = function () {
+	if (this.currentPlayingNode && this.currentPlayingNode.modulePtr) {
+		return libopenmpt._openmpt_module_get_current_row(this.currentPlayingNode.modulePtr);
+	}
+	return 0;
+};
+
+ChiptuneJsPlayer.prototype.getPatternNumRows = function (pattern: number) {
+	if (this.currentPlayingNode && this.currentPlayingNode.modulePtr) {
+		return libopenmpt._openmpt_module_get_pattern_num_rows(this.currentPlayingNode.modulePtr, pattern);
+	}
+	return 0;
+};
+
+ChiptuneJsPlayer.prototype.getPatternRowChannel = function (pattern: number, row: number, channel: number) {
+	if (this.currentPlayingNode && this.currentPlayingNode.modulePtr) {
+		return UTF8ToString(libopenmpt._openmpt_module_format_pattern_row_channel(this.currentPlayingNode.modulePtr, pattern, row, channel, 0, true));
+	}
+	return '';
+};
+
+ChiptuneJsPlayer.prototype.createLibopenmptNode = function (buffer, config: object) {
+	const maxFramesPerChunk = 4096;
+	const processNode = this.audioContext.createScriptProcessor(2048, 0, 2);
+	processNode.config = config;
+	processNode.player = this;
+	const byteArray = new Int8Array(buffer);
+	const ptrToFile = libopenmpt._malloc(byteArray.byteLength);
+	libopenmpt.HEAPU8.set(byteArray, ptrToFile);
+	processNode.modulePtr = libopenmpt._openmpt_module_create_from_memory(ptrToFile, byteArray.byteLength, 0, 0, 0);
+	processNode.nbChannels = libopenmpt._openmpt_module_get_num_channels(processNode.modulePtr);
+	processNode.patternIndex = -1;
+	processNode.paused = false;
+	processNode.leftBufferPtr = libopenmpt._malloc(4 * maxFramesPerChunk);
+	processNode.rightBufferPtr = libopenmpt._malloc(4 * maxFramesPerChunk);
+	processNode.cleanup = function () {
+		if (this.modulePtr !== 0) {
+			libopenmpt._openmpt_module_destroy(this.modulePtr);
+			this.modulePtr = 0;
+		}
+		if (this.leftBufferPtr !== 0) {
+			libopenmpt._free(this.leftBufferPtr);
+			this.leftBufferPtr = 0;
+		}
+		if (this.rightBufferPtr !== 0) {
+			libopenmpt._free(this.rightBufferPtr);
+			this.rightBufferPtr = 0;
+		}
+	};
+	processNode.stop = function () {
+		this.disconnect();
+		this.cleanup();
+	};
+	processNode.pause = function () {
+		this.paused = true;
+	};
+	processNode.unpause = function () {
+		this.paused = false;
+	};
+	processNode.togglePause = function () {
+		this.paused = !this.paused;
+	};
+	processNode.onaudioprocess = function (e) {
+		const outputL = e.outputBuffer.getChannelData(0);
+		const outputR = e.outputBuffer.getChannelData(1);
+		let framesToRender = outputL.length;
+		if (this.ModulePtr === 0) {
+			for (let i = 0; i < framesToRender; ++i) {
+				outputL[i] = 0;
+				outputR[i] = 0;
+			}
+			this.disconnect();
+			this.cleanup();
+			return;
+		}
+		if (this.paused) {
+			for (let i = 0; i < framesToRender; ++i) {
+				outputL[i] = 0;
+				outputR[i] = 0;
+			}
+			return;
+		}
+		let framesRendered = 0;
+		let ended = false;
+		let error = false;
+
+		const currentPattern = libopenmpt._openmpt_module_get_current_pattern(this.modulePtr);
+		const currentRow = libopenmpt._openmpt_module_get_current_row(this.modulePtr);
+		if (currentPattern !== this.patternIndex) {
+			processNode.player.fireEvent('onPatternChange');
+		}
+		processNode.player.fireEvent('onRowChange', { index: currentRow });
+
+		while (framesToRender > 0) {
+			const framesPerChunk = Math.min(framesToRender, maxFramesPerChunk);
+			const actualFramesPerChunk = libopenmpt._openmpt_module_read_float_stereo(this.modulePtr, this.context.sampleRate, framesPerChunk, this.leftBufferPtr, this.rightBufferPtr);
+			if (actualFramesPerChunk === 0) {
+				ended = true;
+				// modulePtr will be 0 on openmpt: error: openmpt_module_read_float_stereo: ERROR: module * not valid or other openmpt error
+				error = !this.modulePtr;
+			}
+			const rawAudioLeft = libopenmpt.HEAPF32.subarray(this.leftBufferPtr / 4, this.leftBufferPtr / 4 + actualFramesPerChunk);
+			const rawAudioRight = libopenmpt.HEAPF32.subarray(this.rightBufferPtr / 4, this.rightBufferPtr / 4 + actualFramesPerChunk);
+			for (let i = 0; i < actualFramesPerChunk; ++i) {
+				outputL[framesRendered + i] = rawAudioLeft[i];
+				outputR[framesRendered + i] = rawAudioRight[i];
+			}
+			for (let i = actualFramesPerChunk; i < framesPerChunk; ++i) {
+				outputL[framesRendered + i] = 0;
+				outputR[framesRendered + i] = 0;
+			}
+			framesToRender -= framesPerChunk;
+			framesRendered += framesPerChunk;
+		}
+		if (ended) {
+			this.disconnect();
+			this.cleanup();
+			error ? processNode.player.fireEvent('onError', { type: 'openmpt' }) : processNode.player.fireEvent('onEnded');
+		}
+	};
+	return processNode;
+};