mirror of
https://github.com/sehugg/8bitworkshop.git
synced 2024-05-28 23:41:32 +00:00
306 lines
10 KiB
TypeScript
306 lines
10 KiB
TypeScript
/*
|
|
https://github.com/eightbitjim/commodore-tape-maker/blob/master/maketape.py
|
|
|
|
# MIT License
|
|
#
|
|
# Copyright (c) 2018 eightbitjim
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in all
|
|
# copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
# SOFTWARE.
|
|
*/
|
|
|
|
export class OutputSoundFile {
|
|
options: any;
|
|
sampleRate: number;
|
|
soundData: number[];
|
|
tapData: number[];
|
|
|
|
constructor(options: any) {
|
|
this.options = options;
|
|
this.sampleRate = 44100.0;
|
|
this.soundData = [];
|
|
//00000000 43 36 34 2d 54 41 50 45 2d 52 41 57 01 00 00 00 |C64-TAPE-RAW....|
|
|
//00000010 1e 62 03 00
|
|
this.tapData = [0x43,0x36,0x34,0x2d,0x54,0x41,0x50,0x45,0x2d,0x52,0x41,0x57,0x01,0x00,0x00,0x00,0,0,0,0];
|
|
}
|
|
|
|
getWAVHeader() {
|
|
const header = new Uint8Array(44);
|
|
const view = new DataView(header.buffer);
|
|
view.setUint32(0, 0x52494646, false); // "RIFF"
|
|
view.setUint32(4, 44 + this.soundData.length, true); // ChunkSize
|
|
view.setUint32(8, 0x57415645, false); // "WAVE"
|
|
view.setUint32(12, 0x666d7420, false); // "fmt "
|
|
view.setUint32(16, 16, true); // Subchunk1Size
|
|
view.setUint16(20, 1, true); // AudioFormat (PCM)
|
|
view.setUint16(22, 1, true); // NumChannels
|
|
view.setUint32(24, this.sampleRate, true); // SampleRate
|
|
view.setUint32(28, this.sampleRate * 2, true); // ByteRate
|
|
view.setUint16(32, 1, true); // BlockAlign
|
|
view.setUint16(34, 8, true); // BitsPerSample
|
|
view.setUint32(36, 0x64617461, false); // "data"
|
|
view.setUint32(40, this.soundData.length, true); // Subchunk2Size
|
|
return header;
|
|
}
|
|
|
|
addSilence(lengthInSeconds: number): void {
|
|
const numberOfSamples = Math.floor(this.sampleRate * lengthInSeconds);
|
|
for (let i = 0; i < numberOfSamples; i++) {
|
|
this.soundData.push(0);
|
|
}
|
|
//For v1 and v2 TAP files, a $00 value is followed by 3 bytes containing the actual duration measured in clock cycles (not divided by 8). These 3 bytes are in low-high format.
|
|
const numCycles = TAPFile.CLOCK_RATE * lengthInSeconds;
|
|
this.tapData.push(0);
|
|
this.tapData.push(numCycles & 0xff);
|
|
this.tapData.push((numCycles >> 8) & 0xff);
|
|
this.tapData.push((numCycles >> 16) & 0xff);
|
|
}
|
|
|
|
addCycle(cycles: number): void {
|
|
this.tapData.push(cycles);
|
|
const numberOfSamples = Math.floor(this.sampleRate * TAPFile.TAP_LENGTH_IN_SECONDS * cycles);
|
|
for (let i = 0; i < numberOfSamples; i++) {
|
|
let value;
|
|
if (this.options.sine_wave) {
|
|
value = - Math.sin((i / numberOfSamples) * 2.0 * Math.PI);
|
|
} else {
|
|
if (i < numberOfSamples / 2) {
|
|
value = -1;
|
|
} else {
|
|
value = 1;
|
|
}
|
|
}
|
|
if (this.options.invert_waveform) {
|
|
value = -value;
|
|
}
|
|
this.soundData.push(Math.round(128 + value * 127));
|
|
}
|
|
}
|
|
|
|
updateTAPHeader() {
|
|
let datalen = this.tapData.length - 0x14;
|
|
// set bytes 0x10-0x13 to length
|
|
this.tapData[0x10] = datalen & 0xff;
|
|
this.tapData[0x11] = (datalen >> 8) & 0xff;
|
|
this.tapData[0x12] = (datalen >> 16) & 0xff;
|
|
this.tapData[0x13] = (datalen >> 24) & 0xff;
|
|
}
|
|
|
|
getTAPData(): Uint8Array {
|
|
this.updateTAPHeader();
|
|
return new Uint8Array(this.tapData);
|
|
}
|
|
|
|
getSoundData(): Uint8Array {
|
|
let header = this.getWAVHeader();
|
|
let data = new Uint8Array(header.length + this.soundData.length);
|
|
data.set(header, 0);
|
|
data.set(new Uint8Array(this.soundData), header.length);
|
|
return data;
|
|
}
|
|
}
|
|
|
|
export class TAPFile {
|
|
|
|
static CLOCK_RATE = 985248.0;
|
|
static TAP_LENGTH_IN_SECONDS = 8.0 / this.CLOCK_RATE;
|
|
static FILENAME_BUFFER_SIZE = 0x10;
|
|
static FILE_TYPE_NONE = 0;
|
|
static FILE_TYPE_RELOCATABLE = 1;
|
|
static FILE_TYPE_SEQUENTIAL = 2;
|
|
static FILE_TYPE_NON_RELOCATABLE = 3;
|
|
static LEADER_TYPE_HEADER = 0;
|
|
static LEADER_TYPE_CONTENT = 1;
|
|
static LEADER_TYPE_REPEATED = 2;
|
|
static NUMBER_OF_PADDING_BYTES = 171;
|
|
static PADDING_CHARACTER = 0x20;
|
|
static SHORT_PULSE = 0x30;
|
|
static MEDIUM_PULSE = 0x42;
|
|
static LONG_PULSE = 0x56;
|
|
|
|
options: any;
|
|
checksum: number;
|
|
data: Uint8Array;
|
|
filenameData: number[];
|
|
startAddress: number;
|
|
endAddress: number;
|
|
fileType: number;
|
|
waveFile: OutputSoundFile;
|
|
|
|
constructor(filename: string, options?: any) {
|
|
this.options = options;
|
|
this.checksum = 0;
|
|
this.data = new Uint8Array(0);
|
|
this.filenameData = this.makeFilename(filename);
|
|
this.startAddress = 0;
|
|
this.endAddress = 0;
|
|
this.fileType = TAPFile.FILE_TYPE_NONE;
|
|
this.waveFile = null;
|
|
}
|
|
|
|
makeFilename(filename: string): number[] {
|
|
const filenameBuffer = [];
|
|
const space = 0x20;
|
|
filename = filename.toUpperCase(); // for PETSCII
|
|
for (let i = 0; i < TAPFile.FILENAME_BUFFER_SIZE; i++) {
|
|
if (filename.length <= i) {
|
|
filenameBuffer.push(space);
|
|
} else {
|
|
let ch = filename.charCodeAt(i);
|
|
filenameBuffer.push(ch);
|
|
}
|
|
}
|
|
return filenameBuffer;
|
|
}
|
|
|
|
setContent(inputFile: { data: Uint8Array, startAddress: number, type: number }): void {
|
|
this.data = inputFile.data;
|
|
this.startAddress = inputFile.startAddress;
|
|
this.endAddress = inputFile.startAddress + inputFile.data.length;
|
|
this.fileType = inputFile.type;
|
|
}
|
|
|
|
generateSound(outputWaveFile: OutputSoundFile): void {
|
|
this.waveFile = outputWaveFile;
|
|
this.addHeader(false);
|
|
this.addHeader(true);
|
|
outputWaveFile.addSilence(0.1);
|
|
this.addFile();
|
|
}
|
|
|
|
addTapCycle(tapValue: number): void {
|
|
this.waveFile.addCycle(tapValue);
|
|
}
|
|
|
|
addBit(value: number): void {
|
|
if (value === 0) {
|
|
this.addTapCycle(TAPFile.SHORT_PULSE);
|
|
this.addTapCycle(TAPFile.MEDIUM_PULSE);
|
|
} else {
|
|
this.addTapCycle(TAPFile.MEDIUM_PULSE);
|
|
this.addTapCycle(TAPFile.SHORT_PULSE);
|
|
}
|
|
}
|
|
|
|
addDataMarker(moreToFollow: boolean): void {
|
|
if (moreToFollow) {
|
|
this.addTapCycle(TAPFile.LONG_PULSE);
|
|
this.addTapCycle(TAPFile.MEDIUM_PULSE);
|
|
} else {
|
|
this.addTapCycle(TAPFile.LONG_PULSE);
|
|
this.addTapCycle(TAPFile.SHORT_PULSE);
|
|
}
|
|
}
|
|
|
|
resetChecksum(): void {
|
|
this.checksum = 0;
|
|
}
|
|
|
|
addByteFrame(value: number, moreToFollow: boolean): void {
|
|
let checkBit = 1;
|
|
for (let i = 0; i < 8; i++) {
|
|
const bit = (value & (1 << i)) !== 0 ? 1 : 0;
|
|
this.addBit(bit);
|
|
checkBit ^= bit;
|
|
}
|
|
this.addBit(checkBit);
|
|
this.addDataMarker(moreToFollow);
|
|
this.checksum ^= value;
|
|
}
|
|
|
|
addLeader(fileType: number): void {
|
|
let numberofPulses;
|
|
if (fileType === TAPFile.LEADER_TYPE_HEADER) {
|
|
numberofPulses = 0x6a00;
|
|
} else if (fileType === TAPFile.LEADER_TYPE_CONTENT) {
|
|
numberofPulses = 0x1a00;
|
|
} else {
|
|
numberofPulses = 0x4f;
|
|
}
|
|
for (let i = 0; i < numberofPulses; i++) {
|
|
this.addTapCycle(TAPFile.SHORT_PULSE);
|
|
}
|
|
}
|
|
|
|
addSyncChain(repeated: boolean): void {
|
|
let value;
|
|
if (repeated) {
|
|
value = 0x09;
|
|
} else {
|
|
value = 0x89;
|
|
}
|
|
let count = 9;
|
|
while (count > 0) {
|
|
this.addByteFrame(value, true);
|
|
value -= 1;
|
|
count -= 1;
|
|
}
|
|
}
|
|
|
|
addData(): void {
|
|
for (let i = 0; i < this.data.length; i++) {
|
|
this.addByteFrame(this.data[i], true);
|
|
}
|
|
}
|
|
|
|
addFilename(): void {
|
|
for (let i = 0; i < this.filenameData.length; i++) {
|
|
this.addByteFrame(this.filenameData[i], true);
|
|
}
|
|
}
|
|
|
|
addHeader(repeated: boolean): void {
|
|
if (repeated) {
|
|
this.addLeader(TAPFile.LEADER_TYPE_REPEATED);
|
|
} else {
|
|
this.addLeader(TAPFile.LEADER_TYPE_HEADER);
|
|
}
|
|
this.addDataMarker(true);
|
|
this.addSyncChain(repeated);
|
|
this.resetChecksum();
|
|
this.addByteFrame(this.fileType, true);
|
|
this.addByteFrame(this.startAddress & 0x00ff, true);
|
|
this.addByteFrame((this.startAddress & 0xff00) >> 8, true);
|
|
this.addByteFrame(this.endAddress & 0x00ff, true);
|
|
this.addByteFrame((this.endAddress & 0xff00) >> 8, true);
|
|
this.addFilename();
|
|
for (let i = 0; i < TAPFile.NUMBER_OF_PADDING_BYTES; i++) {
|
|
this.addByteFrame(TAPFile.PADDING_CHARACTER, true);
|
|
}
|
|
this.addByteFrame(this.checksum, false);
|
|
}
|
|
|
|
addFile(): void {
|
|
let repeated = false;
|
|
for (let i = 0; i < 2; i++) {
|
|
if (!repeated) {
|
|
this.addLeader(TAPFile.LEADER_TYPE_CONTENT);
|
|
} else {
|
|
this.addLeader(TAPFile.LEADER_TYPE_REPEATED);
|
|
}
|
|
this.addDataMarker(true);
|
|
this.addSyncChain(repeated);
|
|
this.resetChecksum();
|
|
this.addData();
|
|
this.addByteFrame(this.checksum, false);
|
|
repeated = true;
|
|
}
|
|
this.addLeader(1);
|
|
}
|
|
}
|