594 lines
16 KiB
JavaScript
594 lines
16 KiB
JavaScript
const fs = require("fs");
|
|
const path = require("path");
|
|
|
|
const homeDir = require("os").homedir();
|
|
const macDir = path.join(homeDir, "macintosh.js");
|
|
const macintoshCopyPath = path.join(__dirname, "user_files");
|
|
|
|
// Set by config
|
|
let userDataPath;
|
|
|
|
function getUserDataDiskPath() {
|
|
return path.join(userDataPath, "disk");
|
|
}
|
|
|
|
// File type utilities
|
|
|
|
function isFile(v = "") {
|
|
return fs.statSync(path.join(macDir, v)).isFile();
|
|
}
|
|
|
|
function isHiddenFile(filename = '') {
|
|
return filename.startsWith('.');
|
|
}
|
|
|
|
function isCDImage(filename = '') {
|
|
return filename.endsWith('.iso') || filename.endsWith('.toast');
|
|
}
|
|
|
|
function isDiskImage(filename = '') {
|
|
return filename.endsWith('.img') || filename.endsWith('.dsk');
|
|
}
|
|
|
|
function cleanupCopyPath() {
|
|
try {
|
|
if (fs.existsSync(macintoshCopyPath)) {
|
|
fs.rmdirSync(macintoshCopyPath, { recursive: true });
|
|
}
|
|
|
|
fs.mkdirSync(macintoshCopyPath);
|
|
} catch (error) {
|
|
console.error(`cleanupCopyPath: Failed to remove`, error);
|
|
}
|
|
}
|
|
|
|
function getUserDataDiskImage() {
|
|
if (!userDataPath) {
|
|
console.error(`getUserDataDiskImage: userDataPath not set`);
|
|
return;
|
|
}
|
|
|
|
const diskImageUserPath = getUserDataDiskPath();
|
|
const diskImagePath = path.join(__dirname, "disk");
|
|
|
|
// If there's a disk image, move it over
|
|
if (!fs.existsSync(diskImageUserPath)) {
|
|
try {
|
|
fs.renameSync(diskImagePath, diskImageUserPath);
|
|
} catch (error) {
|
|
// This is _probably_ a permissions thing, let's copy the file
|
|
fs.copyFileSync(diskImagePath, diskImageUserPath);
|
|
}
|
|
} else {
|
|
console.log(
|
|
`getUserDataDiskImage: Image in user data dir, not doing anything`
|
|
);
|
|
}
|
|
}
|
|
|
|
// Taken a given path, it'll look at all the files in there,
|
|
// copy them over to the basilisk folder, and then add them
|
|
// to MEMFS
|
|
function preloadFilesAtPath(module, initalSourcePath) {
|
|
try {
|
|
const sourcePath = path.join(macDir, initalSourcePath);
|
|
const targetPath = `/macintosh.js${
|
|
initalSourcePath ? `/${initalSourcePath}` : ""
|
|
}`;
|
|
const files = fs.readdirSync(sourcePath).filter((v) => {
|
|
// Remove hidden, iso, and img files
|
|
return !isHiddenFile(v) && !isDiskImage(v) && !isCDImage(v);
|
|
});
|
|
|
|
(files || []).forEach((fileName) => {
|
|
try {
|
|
// If not, let's move on
|
|
const fileSourcePath = path.join(sourcePath, fileName);
|
|
const relativeSourcePath = `${
|
|
initalSourcePath ? `${initalSourcePath}/` : ""
|
|
}${fileName}`;
|
|
|
|
// Check if directory
|
|
if (fs.statSync(fileSourcePath).isDirectory()) {
|
|
try {
|
|
const virtualDirPath = `${targetPath}/${fileName}`;
|
|
module.FS.mkdir(virtualDirPath);
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|
|
|
|
preloadFilesAtPath(module, relativeSourcePath);
|
|
return;
|
|
}
|
|
|
|
createPreloadedFile(module, {
|
|
parent: targetPath,
|
|
name: fileName,
|
|
url: fileSourcePath,
|
|
});
|
|
} catch (error) {
|
|
postMessage("showMessageBoxSync", {
|
|
type: "error",
|
|
title: "Could not transfer file",
|
|
message: `We tried to transfer ${fileName} to the virtual machine, but failed. The error was: ${error}`,
|
|
});
|
|
|
|
console.error(
|
|
`preloadFilesAtPath: Failed to preload ${fileName}`,
|
|
error
|
|
);
|
|
}
|
|
});
|
|
} catch (error) {
|
|
postMessage("showMessageBoxSync", {
|
|
type: "error",
|
|
title: "Could not transfer files",
|
|
message: `We tried to transfer files to the virtual machine, but failed. The error was: ${error}`,
|
|
});
|
|
|
|
console.error(`preloadFilesAtPath: Failed to preloadFilesAtPath`, error);
|
|
}
|
|
}
|
|
|
|
function createPreloadedFile(module, options) {
|
|
const parent = options.parent || `/`;
|
|
const name = options.name || path.basename(options.url);
|
|
const url = options.url;
|
|
|
|
console.log(`Adding preload file`, { parent, name, url });
|
|
module.FS_createPreloadedFile(parent, name, url, true, true);
|
|
}
|
|
|
|
function addAutoloader(module) {
|
|
const loadDatafiles = function () {
|
|
module.autoloadFiles.forEach(({ url, name }) =>
|
|
createPreloadedFile(module, { url, name })
|
|
);
|
|
|
|
// If the user has a macintosh.js dir, we'll copy over user
|
|
// data
|
|
if (!fs.existsSync(macDir)) {
|
|
return;
|
|
}
|
|
|
|
// Load user files
|
|
preloadFilesAtPath(module, "");
|
|
};
|
|
|
|
if (module.autoloadFiles) {
|
|
module.preRun = module.preRun || [];
|
|
module.preRun.unshift(loadDatafiles);
|
|
}
|
|
|
|
return module;
|
|
}
|
|
|
|
function addCustomAsyncInit(module) {
|
|
if (module.asyncInit) {
|
|
module.preRun = module.preRun || [];
|
|
module.preRun.push(function waitForCustomAsyncInit() {
|
|
module.addRunDependency("__moduleAsyncInit");
|
|
|
|
module.asyncInit(module, function asyncInitCallback() {
|
|
module.removeRunDependency("__moduleAsyncInit");
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
function writeSafely(filePath, fileData) {
|
|
return new Promise((resolve) => {
|
|
fs.writeFile(filePath, fileData, (error) => {
|
|
if (error) {
|
|
postMessage("showMessageBoxSync", {
|
|
type: "error",
|
|
title: "Could not save files",
|
|
message: `We tried to save files from the virtual machine, but failed. The error was: ${error}`,
|
|
});
|
|
|
|
console.error(`Disk save: Encountered error for ${filePath}`, error);
|
|
} else {
|
|
console.log(`Disk save: Finished writing ${filePath}`);
|
|
}
|
|
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
|
|
function writePrefs(userImages = []) {
|
|
try {
|
|
const prefsTemplatePath = path.join(__dirname, "prefs_template");
|
|
const prefsPath = path.join(userDataPath, "prefs");
|
|
|
|
let prefs = fs.readFileSync(prefsTemplatePath, { encoding: "utf-8" });
|
|
|
|
// Replace line endings, just in case
|
|
prefs = prefs.replaceAll("\r\n", "\n");
|
|
|
|
if (userImages && userImages.length > 0) {
|
|
console.log(`writePrefs: Found ${userImages.length} user images`);
|
|
userImages.forEach(({ name }) => {
|
|
if (isCDImage(name)) {
|
|
prefs += `\ncdrom ${name}`;
|
|
} else if (isDiskImage(name)) {
|
|
prefs += `\ndisk ${name}`;
|
|
}
|
|
});
|
|
}
|
|
|
|
prefs += `\n`;
|
|
|
|
fs.writeFileSync(prefsPath, prefs);
|
|
} catch (error) {
|
|
console.error(`writePrefs: Failed to set prefs`, error);
|
|
}
|
|
}
|
|
|
|
function getUserImages() {
|
|
const result = [];
|
|
|
|
try {
|
|
// No need if the macDir doesn't exist
|
|
if (!fs.existsSync(macDir)) {
|
|
console.log(`getUserImages: ${macDir} does not exist, exit`);
|
|
return result;
|
|
}
|
|
|
|
const macDirFiles = fs.readdirSync(macDir);
|
|
const imgFiles = macDirFiles.filter((v) => isFile(v) && isDiskImage(v));
|
|
const isoFiles = macDirFiles.filter((v) => isFile(v) && isCDImage(v));
|
|
const isoImgFiles = [...isoFiles, ...imgFiles];
|
|
|
|
console.log(`getUserImages: iso and img files`, isoImgFiles);
|
|
|
|
isoImgFiles.forEach((fileName, i) => {
|
|
const url = path.join(macDir, fileName);
|
|
const sanitizedFileName = `user_image_${i}_${fileName.replace(
|
|
/[^\w\s\.]/gi,
|
|
""
|
|
)}`;
|
|
|
|
result.push({ url, name: sanitizedFileName });
|
|
});
|
|
} catch (error) {
|
|
console.error(`getUserImages: Encountered error`, error);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function getAutoLoadFiles(userImages = []) {
|
|
const autoLoadFiles = [
|
|
{
|
|
name: "disk",
|
|
url: path.join(userDataPath, "disk"),
|
|
},
|
|
{
|
|
name: "rom",
|
|
url: path.join(__dirname, "rom"),
|
|
},
|
|
{
|
|
name: "prefs",
|
|
url: path.join(userDataPath, "prefs"),
|
|
},
|
|
...userImages,
|
|
];
|
|
|
|
return autoLoadFiles;
|
|
}
|
|
|
|
async function saveFilesInPath(folderPath) {
|
|
const entries = (Module.FS.readdir(folderPath) || []).filter(
|
|
(v) => !v.startsWith(".")
|
|
);
|
|
|
|
if (!entries || entries.length === 0) return;
|
|
|
|
// Ensure directory
|
|
const targetDir = path.join(homeDir, folderPath);
|
|
if (!fs.existsSync(targetDir)) {
|
|
fs.mkdirSync(targetDir);
|
|
}
|
|
|
|
for (const file of entries) {
|
|
try {
|
|
const fileSourcePath = `${folderPath}/${file}`;
|
|
const stat = Module.FS.analyzePath(fileSourcePath);
|
|
|
|
if (stat && stat.object && stat.object.isFolder) {
|
|
// This is a folder, step into
|
|
await saveFilesInPath(fileSourcePath);
|
|
} else if (stat && stat.object && stat.object.contents) {
|
|
const fileData = stat.object.contents;
|
|
const filePath = path.join(targetDir, file);
|
|
|
|
await writeSafely(filePath, fileData);
|
|
} else {
|
|
console.log(
|
|
`Disk save: Object at ${fileSourcePath} is something, but we don't know what`,
|
|
stat
|
|
);
|
|
}
|
|
} catch (error) {
|
|
postMessage("showMessageBoxSync", {
|
|
type: "error",
|
|
title: "Could not safe file",
|
|
message: `We tried to save the file "${file}" from the virtual machine, but failed. The error was: ${error}`,
|
|
});
|
|
|
|
console.error(`Disk save: Could not write ${file}`, error);
|
|
}
|
|
}
|
|
}
|
|
|
|
let InputBufferAddresses = {
|
|
globalLockAddr: 0,
|
|
mouseMoveFlagAddr: 1,
|
|
mouseMoveXDeltaAddr: 2,
|
|
mouseMoveYDeltaAddr: 3,
|
|
mouseButtonStateAddr: 4,
|
|
keyEventFlagAddr: 5,
|
|
keyCodeAddr: 6,
|
|
keyStateAddr: 7,
|
|
};
|
|
|
|
let LockStates = {
|
|
READY_FOR_UI_THREAD: 0,
|
|
UI_THREAD_LOCK: 1,
|
|
READY_FOR_EMUL_THREAD: 2,
|
|
EMUL_THREAD_LOCK: 3,
|
|
};
|
|
|
|
var Module = null;
|
|
|
|
self.onmessage = async function (msg) {
|
|
console.log("Worker message received", msg.data);
|
|
|
|
// If it's a config object, start the show
|
|
if (msg && msg.data && msg.data.SCREEN_WIDTH) {
|
|
console.log("Start emulator worker");
|
|
startEmulator(
|
|
Object.assign({}, msg.data, { singleThreadedEmscripten: true })
|
|
);
|
|
}
|
|
|
|
if (msg && msg.data === "disk_save") {
|
|
const diskData = Module.FS.readFile("/disk");
|
|
const diskPath = getUserDataDiskPath();
|
|
|
|
// I wish we could do this with promises, but OOM crashes kill that idea
|
|
try {
|
|
console.log(`Trying to save disk`);
|
|
fs.writeFileSync(diskPath, diskData);
|
|
console.log(`Finished writing disk`);
|
|
} catch (error) {
|
|
console.error(`Failed to write disk`, error);
|
|
}
|
|
|
|
// Now, user files
|
|
console.log(`Saving user files`);
|
|
await saveFilesInPath("/macintosh.js");
|
|
|
|
// Clean up old copy dir
|
|
cleanupCopyPath();
|
|
|
|
postMessage({ type: "disk_saved" });
|
|
}
|
|
};
|
|
|
|
function startEmulator(parentConfig) {
|
|
userDataPath = parentConfig.userDataPath;
|
|
|
|
getUserDataDiskImage();
|
|
|
|
let screenBufferView = new Uint8Array(
|
|
parentConfig.screenBuffer,
|
|
0,
|
|
parentConfig.screenBufferSize
|
|
);
|
|
|
|
let videoModeBufferView = new Int32Array(
|
|
parentConfig.videoModeBuffer,
|
|
0,
|
|
parentConfig.videoModeBufferSize
|
|
);
|
|
|
|
let inputBufferView = new Int32Array(
|
|
parentConfig.inputBuffer,
|
|
0,
|
|
parentConfig.inputBufferSize
|
|
);
|
|
|
|
let nextAudioChunkIndex = 0;
|
|
let audioDataBufferView = new Uint8Array(
|
|
parentConfig.audioDataBuffer,
|
|
0,
|
|
parentConfig.audioDataBufferSize
|
|
);
|
|
|
|
function waitForTwoStateLock(bufferView, lockIndex) {
|
|
if (Atomics.load(bufferView, lockIndex) === LockStates.UI_THREAD_LOCK) {
|
|
while (
|
|
Atomics.compareExchange(
|
|
bufferView,
|
|
lockIndex,
|
|
LockStates.UI_THREAD_LOCK,
|
|
LockStates.EMUL_THREAD_LOCK
|
|
) !== LockStates.UI_THREAD_LOCK
|
|
) {
|
|
// spin
|
|
// TODO use wait and wake
|
|
}
|
|
} else {
|
|
// already unlocked
|
|
}
|
|
}
|
|
|
|
function releaseTwoStateLock(bufferView, lockIndex) {
|
|
Atomics.store(bufferView, lockIndex, LockStates.UI_THREAD_LOCK); // unlock
|
|
}
|
|
|
|
function tryToAcquireCyclicalLock(bufferView, lockIndex) {
|
|
let res = Atomics.compareExchange(
|
|
bufferView,
|
|
lockIndex,
|
|
LockStates.READY_FOR_EMUL_THREAD,
|
|
LockStates.EMUL_THREAD_LOCK
|
|
);
|
|
if (res === LockStates.READY_FOR_EMUL_THREAD) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function releaseCyclicalLock(bufferView, lockIndex) {
|
|
Atomics.store(bufferView, lockIndex, LockStates.READY_FOR_UI_THREAD); // unlock
|
|
}
|
|
|
|
function acquireInputLock() {
|
|
return tryToAcquireCyclicalLock(
|
|
inputBufferView,
|
|
InputBufferAddresses.globalLockAddr
|
|
);
|
|
}
|
|
|
|
function releaseInputLock() {
|
|
// reset
|
|
inputBufferView[InputBufferAddresses.mouseMoveFlagAddr] = 0;
|
|
inputBufferView[InputBufferAddresses.mouseMoveXDeltaAddr] = 0;
|
|
inputBufferView[InputBufferAddresses.mouseMoveYDeltaAddr] = 0;
|
|
inputBufferView[InputBufferAddresses.mouseButtonStateAddr] = 0;
|
|
inputBufferView[InputBufferAddresses.keyEventFlagAddr] = 0;
|
|
inputBufferView[InputBufferAddresses.keyCodeAddr] = 0;
|
|
inputBufferView[InputBufferAddresses.keyStateAddr] = 0;
|
|
|
|
releaseCyclicalLock(inputBufferView, InputBufferAddresses.globalLockAddr);
|
|
}
|
|
|
|
let AudioConfig = null;
|
|
let AudioBufferQueue = [];
|
|
|
|
// Check for user images
|
|
const userImages = getUserImages();
|
|
|
|
// Write prefs to user data dir
|
|
writePrefs(userImages);
|
|
|
|
// Assemble preload files
|
|
const autoloadFiles = getAutoLoadFiles(userImages);
|
|
|
|
// Set arguments
|
|
const arguments = ["--config", "prefs"];
|
|
|
|
Module = {
|
|
autoloadFiles,
|
|
userImages,
|
|
arguments,
|
|
canvas: null,
|
|
|
|
blit: function blit(bufPtr, width, height, depth, usingPalette) {
|
|
videoModeBufferView[0] = width;
|
|
videoModeBufferView[1] = height;
|
|
videoModeBufferView[2] = depth;
|
|
videoModeBufferView[3] = usingPalette;
|
|
let length = width * height * (depth === 32 ? 4 : 1); // 32bpp or 8bpp
|
|
for (let i = 0; i < length; i++) {
|
|
screenBufferView[i] = Module.HEAPU8[bufPtr + i];
|
|
}
|
|
// releaseTwoStateLock(videoModeBufferView, 9);
|
|
},
|
|
|
|
openAudio: function openAudio(
|
|
sampleRate,
|
|
sampleSize,
|
|
channels,
|
|
framesPerBuffer
|
|
) {
|
|
AudioConfig = {
|
|
sampleRate: sampleRate,
|
|
sampleSize: sampleSize,
|
|
channels: channels,
|
|
framesPerBuffer: framesPerBuffer,
|
|
};
|
|
console.log(AudioConfig);
|
|
},
|
|
|
|
enqueueAudio: function enqueueAudio(bufPtr, nbytes, type) {
|
|
let newAudio = Module.HEAPU8.slice(bufPtr, bufPtr + nbytes);
|
|
let writingChunkIndex = nextAudioChunkIndex;
|
|
let writingChunkAddr =
|
|
writingChunkIndex * parentConfig.audioBlockChunkSize;
|
|
|
|
if (audioDataBufferView[writingChunkAddr] === LockStates.UI_THREAD_LOCK) {
|
|
console.warn(
|
|
"worker tried to write audio data to UI-thread-locked chunk",
|
|
writingChunkIndex
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
let nextNextChunkIndex = writingChunkIndex + 1;
|
|
if (
|
|
nextNextChunkIndex * parentConfig.audioBlockChunkSize >
|
|
audioDataBufferView.length - 1
|
|
) {
|
|
nextNextChunkIndex = 0;
|
|
}
|
|
|
|
audioDataBufferView[writingChunkAddr + 1] = nextNextChunkIndex;
|
|
audioDataBufferView.set(newAudio, writingChunkAddr + 2);
|
|
audioDataBufferView[writingChunkAddr] = LockStates.UI_THREAD_LOCK;
|
|
|
|
nextAudioChunkIndex = nextNextChunkIndex;
|
|
return nbytes;
|
|
},
|
|
|
|
debugPointer: function debugPointer(ptr) {
|
|
console.log("debugPointer", ptr);
|
|
},
|
|
|
|
acquireInputLock: acquireInputLock,
|
|
|
|
InputBufferAddresses: InputBufferAddresses,
|
|
|
|
getInputValue: function getInputValue(addr) {
|
|
return inputBufferView[addr];
|
|
},
|
|
|
|
totalDependencies: 0,
|
|
monitorRunDependencies: function (left) {
|
|
this.totalDependencies = Math.max(this.totalDependencies, left);
|
|
|
|
if (left == 0) {
|
|
postMessage({ type: "emulator_ready" });
|
|
} else {
|
|
postMessage({
|
|
type: "emulator_loading",
|
|
completion: (this.totalDependencies - left) / this.totalDependencies,
|
|
});
|
|
}
|
|
},
|
|
|
|
print: (message) => {
|
|
console.log(message);
|
|
|
|
postMessage({
|
|
type: "TTY",
|
|
data: message,
|
|
});
|
|
},
|
|
|
|
printErr: console.warn.bind(console),
|
|
|
|
releaseInputLock: releaseInputLock,
|
|
};
|
|
|
|
addAutoloader(Module);
|
|
addCustomAsyncInit(Module);
|
|
|
|
if (parentConfig.singleThreadedEmscripten) {
|
|
importScripts("BasiliskII.js");
|
|
}
|
|
}
|