include libopenmpt tracker to foundkey

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

@@ -36,6 +36,7 @@ html
 		link(rel='prefetch' href=config.images.error)
 		link(rel='stylesheet' href='/assets/fontawesome/css/all.css')
 		link(rel='modulepreload' href=`/assets/${clientEntry.file}`)
+		script(src='/client-assets/libopenmpt.js')
 
 		each href in clientEntry.css
 			link(rel='preload' href=`/assets/${href}` as='style')
@@ -63,6 +64,7 @@ html
 		script.
 			var VERSION = "#{version}";
 			var CLIENT_ENTRY = "#{clientEntry.file}";
+			window.libopenmpt = window.Module;
 
 	body
 		noscript: p

packages/client/src/components/media-list.vue

@@ -6,6 +6,7 @@
 			<template v-for="media in mediaList.filter(media => previewable(media))">
 				<XVideo v-if="media.type.startsWith('video')" :key="media.id" :video="media"/>
 				<XImage v-else-if="media.type.startsWith('image')" :key="media.id" class="image" :data-id="media.id" :image="media" :raw="raw"/>
+        <XModPlayer v-else-if="isModule(media)" :key="media.id" :module="media"/>
 			</template>
 		</div>
 	</div>
@@ -21,7 +22,8 @@ import 'photoswipe/style.css';
 import XBanner from './media-banner.vue';
 import XImage from './media-image.vue';
 import XVideo from './media-video.vue';
-import { FILE_TYPE_BROWSERSAFE } from '@/const';
+import XModPlayer from './mod-player.vue';
+import { FILE_TYPE_BROWSERSAFE, FILE_EXT_TRACKER_MODULES } from '@/const';
 
 const props = defineProps<{
 	mediaList: foundkey.entities.DriveFile[];
@@ -123,8 +125,16 @@ onMounted(() => {
 const previewable = (file: foundkey.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);
 };
+
+const isModule = (file: foundkey.entities.DriveFile): boolean => {
+  return FILE_EXT_TRACKER_MODULES.filter((ext) => {
+    return file.name.toLowerCase().endsWith("." + ext);
+  }).length > 0;
+};
+
 </script>
 
 <style lang="scss" scoped>

packages/client/src/components/mod-player.vue

@@ -0,0 +1,315 @@
+<template>
+<div class="mod-player-disabled" v-if="hide" @click="hide = false">
+    <div>
+        <b><i class="fas fa-exlamation-triangle"></i> {{ $ts.sensitive }}</b>
+        <span>{{ $ts.clickToShow }}</span>
+    </div>
+</div>
+
+<div class="mod-player-enabled" v-else>
+    <div class="pattern-display">
+        <canvas class="pattern-canvas" ref="displayCanvas"></canvas>
+    </div>
+    <div class="controls">
+        <button class="play" title="play" accesskey="P" @click="playPause()">
+            <i class="fas fa-play" v-if="!playing"></i>
+            <i class="fas fa-pause" v-if="playing"></i>
+        </button>
+        <button class="stop" title="stop" accesskey="X" @click="stop()">
+            <i class="fas fa-stop"></i>
+        </button>
+        <progress min="0" max="100" value="0" ref="progress"></progress>
+        <input type="range" min="0" max="1" v-model="player.context.gain.value" step="0.1" ref="volume" title="volume"/>
+        <a class="download" title="download" :href="module.url">
+            <i class="fas fa-download"></i>
+        </a>
+    </div>
+    <i class="fas fa-eye-slash" @click="hide = true"></i>
+</div>
+</template>
+
+<script lang="ts" setup>
+import { ref } from 'vue';
+import * as foundkey from 'foundkey-js';
+import { defaultStore } from '@/store';
+import { ChiptuneJsPlayer, ChiptuneJsConfig } from '@/scripts/chiptune2';
+
+const props = defineProps<{
+    module: foundkey.entities.DriveFile
+}>();
+
+let hide = ref((defaultStore.state.nsfw === 'force') ? true : props.module.isSensitive && (defaultStore.state.nsfw !== 'ignore'));
+let playing = ref(false);
+let displayCanvas = ref<HTMLCanvasElement>(null);
+let progress = ref<HTMLProgressElement>(null);
+const player = ref(new ChiptuneJsPlayer(new ChiptuneJsConfig(1)));
+
+const rowBuffer = 24;
+let buffer = null;
+player.value.load(props.module.url).then((result) => {
+    buffer = result;
+    try {
+        player.value.play(buffer);
+        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();
+        progress.value.value = player.value.position() % player.value.duration();
+        display();
+    });
+
+    if (player.value.currentPlayingNode === null) {
+        player.value.play(buffer);
+        playing.value = true;
+    } else {
+        player.value.togglePause();
+        playing.value = !player.value.currentPlayingNode.paused;
+    }
+}
+
+function stop() {
+    player.value.stop();
+    playing.value = false;
+    try {
+        player.value.play(buffer);
+        display();
+    } catch (e) {
+        console.warn(e);
+    }
+    player.value.stop();
+    progress.value.value = 0;
+    player.value.handlers = [];
+}
+
+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');
+    ctx.font = '10px monospace';
+    ctx.fillStyle = 'black';
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = 'gray';
+    for (let rowOffset = 0; rowOffset < rowBuffer; rowOffset++) {
+        const rowToDraw = row - rowBuffer / 2 + rowOffset;
+        if (rowToDraw >= 0 && rowToDraw < nbRows) {
+            let rowText = parseInt(rowToDraw).toString(16);
+            if (rowText.length === 1) {
+                rowText = '0' + rowText;
+            }
+            ctx.fillStyle = 'gray';
+            if (rowToDraw % 4 === 0) {
+                ctx.fillStyle = 'yellow';
+            }
+            if (rowToDraw === row) {
+                ctx.fillStyle = 'white';
+            }
+            ctx.fillText(rowText, 0, 10 + rowOffset * 12);
+            ctx.fillStyle = 'gray';
+            if (rowToDraw === row) {
+                ctx.fillStyle = 'white';
+            }
+            for (let channel = 0; channel < nbChannels; channel++) {
+                const part = player.value.getPatternRowChannel(pattern, rowToDraw, channel);
+                ctx.fillText("|" + part, 12 + 84 * channel, 10 + rowOffset * 12);
+            }
+        }
+    }
+}
+
+</script>
+
+<style lang="scss" scoped>
+.mod-player-enabled {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+
+  > i {
+    display: block;
+    position: absolute;
+    border-radius: 6px;
+    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);
+      
+      &:hover {
+        background-color: var(--fg);
+      }
+    }
+
+    > input[type=range] {
+      height: 21px;
+      -webkit-appearance: none;
+      width: 90px;
+      padding: 0;
+      margin: 4px 8px;
+
+      &: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);
+      }
+
+      &::-webkit-slider-thumb {
+        border: none;
+        height: 100%;
+        width: 14px;
+        border-radius: 0;
+        background: var(--accent);
+        cursor: pointer;
+        -webkit-appearance: none;
+        margin-top: -0.5px;
+      }
+
+      &::-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-thumb {
+        border: none;
+        height: 100%;
+        border-radius: 0;
+        width: 14px;
+        background: var(--accent);
+        cursoer: 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, &::-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(--accent);
+        cursor: pointer;
+      }
+    }
+
+    > progress {
+      padding: unset;
+      margin: 4px 8px;
+      flex-grow: 1;
+      background-color: var(--bg);
+
+      &::-moz-progress-bar, &::-webkit-progress-value {
+        background-color: var(--accent);
+      }
+    }
+  }
+}
+
+.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/client/src/const.ts

@@ -46,6 +46,44 @@ export const FILE_TYPE_BROWSERSAFE = [
 	'audio/x-flac',
 	'audio/vnd.wave',
 ];
+
+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/client/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 || 1);
+	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;
+};