2021-07-10 00:54:27 +00:00
|
|
|
import { debug, toHex } from '../util';
|
|
|
|
import { bit, byte, word } from '../types';
|
|
|
|
import { grabNibble } from './format_utils';
|
|
|
|
import { DiskOptions, ENCODING_BITSTREAM, WozDisk } from './types';
|
|
|
|
|
|
|
|
const WOZ_HEADER_START = 0;
|
|
|
|
const WOZ_HEADER_SIZE = 12;
|
|
|
|
|
|
|
|
const WOZ1_SIGNATURE = 0x315A4F57;
|
|
|
|
const WOZ2_SIGNATURE = 0x325A4F57;
|
|
|
|
const WOZ_INTEGRITY_CHECK = 0x0a0d0aff;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts a range of bytes from a DataView into an ASCII string
|
|
|
|
*
|
|
|
|
* @param data DataView containing string
|
|
|
|
* @param start start index of string
|
|
|
|
* @param end end index of string
|
|
|
|
* @returns ASCII string
|
|
|
|
*/
|
|
|
|
function stringFromBytes(data: DataView, start: number, end: number): string {
|
2022-06-01 13:28:05 +00:00
|
|
|
const byteArray = new Uint8Array(
|
|
|
|
data.buffer.slice(data.byteOffset + start, data.byteOffset + end)
|
|
|
|
);
|
|
|
|
return String.fromCharCode(...byteArray);
|
2021-07-10 00:54:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
export class InfoChunk {
|
2021-11-29 00:20:25 +00:00
|
|
|
version: byte;
|
2021-07-10 00:54:27 +00:00
|
|
|
|
|
|
|
// Version 1
|
2021-11-29 00:20:25 +00:00
|
|
|
diskType: byte;
|
|
|
|
writeProtected: byte;
|
|
|
|
synchronized: byte;
|
|
|
|
cleaned: byte;
|
|
|
|
creator: string;
|
2021-07-10 00:54:27 +00:00
|
|
|
|
|
|
|
// Version 2
|
2021-11-29 00:20:25 +00:00
|
|
|
sides: byte = 0;
|
|
|
|
bootSector: byte = 0;
|
|
|
|
bitTiming: byte = 0;
|
|
|
|
compatibleHardware: word = 0;
|
|
|
|
requiredRAM: word = 0;
|
|
|
|
largestTrack: word = 0;
|
2021-07-10 00:54:27 +00:00
|
|
|
|
|
|
|
constructor(data: DataView) {
|
|
|
|
this.version = data.getUint8(0);
|
|
|
|
this.diskType = data.getUint8(1);
|
|
|
|
this.writeProtected = data.getUint8(2);
|
|
|
|
this.synchronized = data.getUint8(3);
|
|
|
|
this.cleaned = data.getUint8(4);
|
|
|
|
this.creator = stringFromBytes(data, 5, 37);
|
|
|
|
|
|
|
|
if (this.version > 1) {
|
|
|
|
this.sides = data.getUint8(37);
|
|
|
|
this.bootSector = data.getUint8(38);
|
|
|
|
this.bitTiming = data.getUint8(39);
|
|
|
|
this.compatibleHardware = data.getUint16(40, true);
|
|
|
|
this.requiredRAM = data.getUint16(42, true);
|
|
|
|
this.largestTrack = data.getUint16(44, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export class TMapChunk {
|
2021-11-29 00:20:25 +00:00
|
|
|
trackMap: byte[];
|
2021-07-10 00:54:27 +00:00
|
|
|
|
|
|
|
constructor(data: DataView) {
|
|
|
|
this.trackMap = [];
|
|
|
|
|
|
|
|
for (let idx = 0; idx < 160; idx++) {
|
|
|
|
this.trackMap.push(data.getUint8(idx));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const WOZ_TRACK_SIZE = 6656;
|
|
|
|
const WOZ_TRACK_INFO_BITS = 6648;
|
|
|
|
|
|
|
|
export class TrksChunk {
|
2021-11-29 00:20:25 +00:00
|
|
|
rawTracks: Uint8Array[];
|
|
|
|
tracks: Uint8Array[];
|
2021-07-10 00:54:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
export class TrksChunk1 extends TrksChunk {
|
|
|
|
constructor(data: DataView) {
|
|
|
|
super();
|
|
|
|
|
|
|
|
this.rawTracks = [];
|
|
|
|
this.tracks = [];
|
|
|
|
|
|
|
|
for (let trackNo = 0, idx = 0; idx < data.byteLength; idx += WOZ_TRACK_SIZE, trackNo++) {
|
|
|
|
let track = [];
|
|
|
|
const rawTrack: bit[] = [];
|
|
|
|
const slice = data.buffer.slice(data.byteOffset + idx, data.byteOffset + idx + WOZ_TRACK_SIZE);
|
|
|
|
const trackData = new Uint8Array(slice);
|
|
|
|
const trackInfo = new DataView(slice);
|
|
|
|
const trackBitCount = trackInfo.getUint16(WOZ_TRACK_INFO_BITS, true);
|
|
|
|
for (let jdx = 0; jdx < trackBitCount; jdx++) {
|
|
|
|
const byteIndex = jdx >> 3;
|
|
|
|
const bitIndex = 7 - (jdx & 0x07);
|
|
|
|
rawTrack[jdx] = (trackData[byteIndex] >> bitIndex) & 0x01 ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
track = [];
|
|
|
|
let offset = 0;
|
|
|
|
while (offset < rawTrack.length) {
|
|
|
|
const result = grabNibble(rawTrack, offset);
|
|
|
|
if (!result.nibble) { break; }
|
|
|
|
track.push(result.nibble);
|
|
|
|
offset = result.offset + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.tracks[trackNo] = new Uint8Array(track);
|
|
|
|
this.rawTracks[trackNo] = new Uint8Array(rawTrack);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export interface Trk {
|
2022-05-10 15:04:20 +00:00
|
|
|
startBlock: word;
|
|
|
|
blockCount: word;
|
|
|
|
bitCount: number;
|
2021-07-10 00:54:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
export class TrksChunk2 extends TrksChunk {
|
2021-11-29 00:20:25 +00:00
|
|
|
trks: Trk[];
|
2021-07-10 00:54:27 +00:00
|
|
|
|
|
|
|
constructor (data: DataView) {
|
|
|
|
super();
|
|
|
|
|
|
|
|
let trackNo;
|
|
|
|
this.trks = [];
|
|
|
|
for (trackNo = 0; trackNo < 160; trackNo++) {
|
|
|
|
const startBlock = data.getUint16(trackNo * 8, true);
|
|
|
|
const blockCount = data.getUint16(trackNo * 8 + 2, true);
|
|
|
|
const bitCount = data.getUint32(trackNo * 8 + 4, true);
|
|
|
|
if (bitCount === 0) { break; }
|
|
|
|
this.trks.push({
|
|
|
|
startBlock: startBlock,
|
|
|
|
blockCount: blockCount,
|
|
|
|
bitCount: bitCount
|
|
|
|
});
|
|
|
|
}
|
|
|
|
this.tracks = [];
|
|
|
|
this.rawTracks = [];
|
|
|
|
|
|
|
|
const bits = data.buffer;
|
|
|
|
for (trackNo = 0; trackNo < this.trks.length; trackNo++) {
|
|
|
|
const trk = this.trks[trackNo];
|
|
|
|
|
|
|
|
let track = [];
|
|
|
|
const rawTrack: bit[] = [];
|
|
|
|
const start = trk.startBlock * 512;
|
|
|
|
const end = start + trk.blockCount * 512;
|
|
|
|
const slice = bits.slice(start, end);
|
|
|
|
const trackData = new Uint8Array(slice);
|
2022-06-20 02:52:06 +00:00
|
|
|
if (trackNo === 0) {
|
|
|
|
// debug(`First bytes: ${toHex(trackData[0])} ${toHex(trackData[1])} ${toHex(trackData[2])} ${toHex(trackData[3])}`);
|
|
|
|
}
|
2021-07-10 00:54:27 +00:00
|
|
|
for (let jdx = 0; jdx < trk.bitCount; jdx++) {
|
|
|
|
const byteIndex = jdx >> 3;
|
|
|
|
const bitIndex = 7 - (jdx & 0x07);
|
|
|
|
rawTrack[jdx] = (trackData[byteIndex] >> bitIndex) & 0x01 ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
track = [];
|
|
|
|
let offset = 0;
|
|
|
|
while (offset < rawTrack.length) {
|
|
|
|
const result = grabNibble(rawTrack, offset);
|
|
|
|
if (!result.nibble) { break; }
|
|
|
|
track.push(result.nibble);
|
|
|
|
offset = result.offset + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.tracks[trackNo] = new Uint8Array(track);
|
|
|
|
this.rawTracks[trackNo] = new Uint8Array(rawTrack);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export class MetaChunk {
|
2021-11-29 00:20:25 +00:00
|
|
|
values: Record<string, string>;
|
2021-07-10 00:54:27 +00:00
|
|
|
|
|
|
|
constructor (data: DataView) {
|
|
|
|
const infoStr = stringFromBytes(data, 0, data.byteLength);
|
|
|
|
const parts = infoStr.split('\n');
|
|
|
|
this.values = parts.reduce(function(acc: Record<string, string>, part) {
|
|
|
|
const subParts = part.split('\t');
|
|
|
|
acc[subParts[0]] = subParts[1];
|
|
|
|
return acc;
|
|
|
|
}, {});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
interface Chunks {
|
2022-05-18 02:08:28 +00:00
|
|
|
[key: string]: unknown;
|
2022-05-10 15:04:20 +00:00
|
|
|
info?: InfoChunk;
|
|
|
|
tmap?: TMapChunk;
|
|
|
|
trks?: TrksChunk;
|
|
|
|
meta?: MetaChunk;
|
2021-07-10 00:54:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a `Disk` object from Woz image data.
|
2021-07-10 00:53:30 +00:00
|
|
|
* @param options the disk image and options
|
|
|
|
* @returns A bitstream disk
|
2021-07-10 00:54:27 +00:00
|
|
|
*/
|
2021-07-10 00:53:30 +00:00
|
|
|
export default function createDiskFromWoz(options: DiskOptions): WozDisk {
|
2021-07-10 00:54:27 +00:00
|
|
|
const { rawData } = options;
|
|
|
|
if (!rawData) {
|
|
|
|
throw new Error('Requires rawData');
|
|
|
|
}
|
|
|
|
const dv = new DataView(rawData, 0);
|
|
|
|
let dvOffset = 0;
|
|
|
|
let wozVersion;
|
|
|
|
const chunks: Chunks = {};
|
|
|
|
|
|
|
|
function readHeader() {
|
|
|
|
const wozSignature = dv.getUint32(WOZ_HEADER_START + 0, true);
|
|
|
|
|
|
|
|
switch (wozSignature) {
|
|
|
|
case WOZ1_SIGNATURE:
|
|
|
|
wozVersion = 1;
|
|
|
|
break;
|
|
|
|
case WOZ2_SIGNATURE:
|
|
|
|
wozVersion = 2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dv.getUint32(WOZ_HEADER_START + 4, true) !== WOZ_INTEGRITY_CHECK) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
function readChunk() {
|
|
|
|
if (dvOffset >= dv.byteLength) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
const type = dv.getUint32(dvOffset, true);
|
|
|
|
const size = dv.getUint32(dvOffset + 4, true);
|
|
|
|
const data = new DataView(dv.buffer, dvOffset + 8, size);
|
|
|
|
dvOffset += size + 8;
|
|
|
|
|
|
|
|
return {
|
|
|
|
type: type,
|
|
|
|
size: size,
|
|
|
|
data: data
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
if (readHeader()) {
|
|
|
|
dvOffset = WOZ_HEADER_SIZE;
|
|
|
|
let chunk = readChunk();
|
|
|
|
while (chunk) {
|
|
|
|
switch (chunk.type) {
|
|
|
|
case 0x4F464E49: // INFO
|
|
|
|
chunks.info = new InfoChunk(chunk.data);
|
|
|
|
break;
|
|
|
|
case 0x50414D54: // TMAP
|
|
|
|
chunks.tmap = new TMapChunk(chunk.data);
|
|
|
|
break;
|
|
|
|
case 0x534B5254: // TRKS
|
|
|
|
if (wozVersion === 1) {
|
|
|
|
chunks.trks = new TrksChunk1(chunk.data);
|
|
|
|
} else {
|
|
|
|
chunks.trks = new TrksChunk2(chunk.data);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x4154454D: // META
|
|
|
|
chunks.meta = new MetaChunk(chunk.data);
|
|
|
|
break;
|
|
|
|
case 0x54495257: // WRIT
|
|
|
|
// Ignore
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
debug('Unsupported chunk', toHex(chunk.type, 8));
|
|
|
|
}
|
|
|
|
chunk = readChunk();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
debug('Invalid woz header');
|
|
|
|
}
|
|
|
|
|
2022-06-20 02:52:06 +00:00
|
|
|
// debug(chunks);
|
2021-07-10 00:54:27 +00:00
|
|
|
|
2022-06-20 02:52:06 +00:00
|
|
|
const { meta, tmap, trks, info } = chunks;
|
2021-10-02 18:45:09 +00:00
|
|
|
|
2021-07-10 00:53:30 +00:00
|
|
|
const disk: WozDisk = {
|
|
|
|
encoding: ENCODING_BITSTREAM,
|
2021-10-02 18:45:09 +00:00
|
|
|
trackMap: tmap?.trackMap || [],
|
|
|
|
tracks: trks?.tracks || [],
|
|
|
|
rawTracks: trks?.rawTracks || [],
|
2021-07-10 00:53:30 +00:00
|
|
|
readOnly: true, //chunks.info.writeProtected === 1;
|
Floppy controller refactorings 1 (#155)
* Add `DiskMetada` to the `Disk` interface
Before, metadata about the image, such as name, side, etc. was mixed
in with actual disk image information. This change breaks that
information into a separate structure called `DiskMetadata`.
Currently, the only two fields are `name` and `side`, but the idea is
that more fields could be added as necessary, like a description, a
scan of the disk or label, etc. In a follow-on change, the default
write-protection status will come from the metadata as well.
The current implementation copies the metadata when saving/restoring
state, loading disk images, etc. In the future, the metadata should
passed around until the format is required to change (like saving one
disk image format as another). Likewise, in the future, in may be
desirable to be able to override the disk image metadata with
user-supplied metadata. This could be use, for example, to
temporarily add or remove write-protection from a disk image.
All existing tests pass and the emulator builds with no errors.
* Rename `writeMode` to `q7`
Before, nibble disk emulation used the `writeMode` field to keep track
of whether the drive should be read from or written to, but the WOZ
emulation used `q7` to keep track of the same state.
This change renames `writeMode` to `q7` because it more accurately
reflects the state of the Disk II controller as specified in the
manuals, DOS source, and, especially, _Understanding the Apple //e_ by
Jim Sather.
* Remove the coil state
Before, `q` captured the state of the coils. But it was never read.
This change just deletes it.
* Use the bootstrap and sequencer ROMs with indirection
Before, the contents of the bootstrap ROM and sequencer ROM were set
directly on fields of the controller. These were not saved or
restored with the state in `getState` and `setState`. (It would have
been very space inefficient if they had).
Now, these ROMs are used from constants indexed by the number of
sectors the card supports. This, in turn, means that if the number of
sectors is saved with the state, it can be easily restored.
* Split out the Disk II controller state
This change factors the emulated hardware state into a separate
structure in the Disk II controller. The idea is that this hardware
state will be able to be shared with the WOZ and nibble disk code
instead of sharing _all_ of the controller state (like callbacks and
so forth).
* Factor out disk insertion
Before, several places in the code essentially inserted a new disk
image into the drive, which similar—but not always exactly the
same—code. Now there is an `insertDisk` method that is responsible
for inserting a new `FloppyDisk`.
All tests pass, everything compiles, manually tested nibble disks and
WOZ disks.
2022-09-01 01:55:01 +00:00
|
|
|
metadata: {
|
|
|
|
name: meta?.values['title'] || options.name,
|
|
|
|
side: meta?.values['side_name'] || meta?.values['side']
|
|
|
|
},
|
2022-06-20 02:52:06 +00:00
|
|
|
info
|
2021-07-10 00:53:30 +00:00
|
|
|
};
|
2021-07-10 00:54:27 +00:00
|
|
|
|
2021-07-10 00:53:30 +00:00
|
|
|
return disk;
|
2021-07-10 00:54:27 +00:00
|
|
|
}
|