goapple2/disk/convert.go

360 lines
10 KiB
Go
Raw Normal View History

2013-04-16 00:43:23 +00:00
package disk
import (
"fmt"
"io/ioutil"
"log"
"path"
2013-04-16 00:43:23 +00:00
)
// Dos33writeTable is the list of valid DOS 3.3 bytes.
// See [UtA2 9-27 Disk Data Formats].
var Dos33writeTable = [64]byte{
0x96, 0x97, 0x9A, 0x9B, 0x9D, 0x9E, 0x9F, 0xA6,
0xA7, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB2, 0xB3,
0xB4, 0xB5, 0xB6, 0xB7, 0xB9, 0xBA, 0xBB, 0xBC,
0xBD, 0xBE, 0xBF, 0xCB, 0xCD, 0xCE, 0xCF, 0xD3,
0xD6, 0xD7, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE,
0xDF, 0xE5, 0xE6, 0xE7, 0xE9, 0xEA, 0xEB, 0xEC,
0xED, 0xEE, 0xEF, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6,
0xF7, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
}
var Dos33readTable [256]int
func init() {
for i := 0; i < 256; i++ {
Dos33readTable[i] = -1
}
for i, j := range Dos33writeTable {
Dos33readTable[j] = int(i)
}
}
2013-04-16 00:43:23 +00:00
// Dos33LogicalToPhysicalSectorMap maps logical sector numbers to physical ones.
// See [UtA2 9-42 - Read Routines].
var Dos33LogicalToPhysicalSectorMap = []byte{
0x00, 0x0D, 0x0B, 0x09, 0x07, 0x05, 0x03, 0x01,
0x0E, 0x0C, 0x0A, 0x08, 0x06, 0x04, 0x02, 0x0F,
}
// Dos33PhysicalToLogicalSectorMap maps physical sector numbers to logical ones.
// See [UtA2 9-42 - Read Routines].
var Dos33PhysicalToLogicalSectorMap = []byte{
0x00, 0x07, 0x0E, 0x06, 0x0D, 0x05, 0x0C, 0x04,
0x0B, 0x03, 0x0A, 0x02, 0x09, 0x01, 0x08, 0x0F,
}
// ProDosLogicalToPhysicalSectorMap maps logical sector numbers to pysical ones.
// See [UtA2e 9-43 - Sectors vs. Blocks].
var ProDosLogicalToPhysicalSectorMap = []byte{
0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
}
// ProDosPhysicalToLogicalSectorMap maps physical sector numbers to logical ones.
// See [UtA2e 9-43 - Sectors vs. Blocks].
var ProDosPhysicalToLogicalSectorMap = []byte{
0x00, 0x08, 0x01, 0x09, 0x02, 0x0A, 0x03, 0x0B,
0x04, 0x0C, 0x05, 0x0D, 0x06, 0x0E, 0x07, 0x0F,
}
// PreNybble converts from 256 8-bit bytes to 342 6-bit "nybbles".
// The equivalent DOS routine, PRE.NYBBLE, would put the 256 MSB-6's into one buffer,
// and the 86 LSB-2's into a separate one, but we place the 86 after the 256.
// See http://www.txbobsc.com/aal/1981/aal8106.html#a5
func PreNybble(source []byte) (target [342]byte) {
if len(source) != 256 {
panic(fmt.Sprintf("PreNybble expects 256 bytes as input, got %d", len(source)))
}
y := 2
for i := 0; i < 3; i++ {
for x := 0; x < 86; x++ {
// DEY
y = (y + 0xff) & 0xff
a := source[y]
target[y] = a >> 2
target[x+256] = (target[x+256]<<2 + a&2>>1 + a&1<<1) & 0x3F
}
}
return target
}
// PostNybble converts from 342 6-bit "nybbles to 255 8-bit bytes.
// The equivalent DOS routine, POST.NYBBLE, would read the 256 MSB-6's from one buffer,
// and the 86 LSB-2's from a separate one, but we place the 86 after the 256.
// See http://www.txbobsc.com/aal/1981/aal8106.html#a5
func PostNybble(source []byte) (target [256]byte) {
if len(source) != 342 {
panic(fmt.Sprintf("PostNybble expects 342 bytes as input, got %d", len(source)))
}
x := 0
for y := 0; y < 256; y++ {
// DEX
x = (x + 85) % 86
a := source[256+x]
source[256+x] = a >> 2
target[y] = source[y]<<2 + a&2>>1 + a&1<<1
}
return target
}
// appendSyncs appends the given number of sync bytes to the slice, and returns the resulting slice.
func appendSyncs(target []byte, count int) []byte {
for i := 0; i < count; i++ {
target = append(target, 0xFF)
}
return target
}
// append44 appends bytes using the 4-4 encoded format used for volume, track, sector, checksum.
func append44(target []byte, b byte) []byte {
2013-04-21 23:49:58 +00:00
return append(target, 0xAA|(b>>1), 0xAA|b)
2013-04-16 00:43:23 +00:00
}
// appendAddress appends the encoded sector address to the slice, and returns the resulting slice.
func appendAddress(target []byte, t, s, v byte) []byte {
target = append(target, 0xD5, 0xAA, 0x96)
target = append44(target, v)
target = append44(target, t)
target = append44(target, s)
target = append44(target, v^t^s)
target = append(target, 0xDE, 0xAA, 0xEB)
return target
}
// appendData appends the encoded sector data to the slice, and returns the resulting slice.
func appendData(target, source []byte) []byte {
target = append(target, 0xD5, 0xAA, 0xAD)
nybbles := PreNybble(source)
checksum := byte(0)
for i := 341; i >= 256; i-- {
target = append(target, Dos33writeTable[nybbles[i]^checksum])
checksum = nybbles[i]
}
for i := 0; i < 256; i++ {
target = append(target, Dos33writeTable[nybbles[i]^checksum])
checksum = nybbles[i]
}
target = append(target, Dos33writeTable[checksum])
target = append(target, 0xDE, 0xAA, 0xEB)
return target
}
// dosToNybbleSector appends a single 256-byte DOS sector in .nyb format, and returns the slice.
func dosToNybbleSector(target, source []byte, t, s, v byte, preSync, intraSync int) []byte {
if len(source) != 256 {
panic(fmt.Sprintf("dosToNybbleSector expects 256 bytes, got %d", len(source)))
}
target = appendSyncs(target, preSync)
target = appendAddress(target, t, s, v)
target = appendSyncs(target, intraSync)
target = appendData(target, source)
return target
}
// dos16ToNybbleTrack converts a 16-sector dos image of a track to a nybblized track.
func dos16ToNybbleTrack(source []byte, t, v byte, preSync, intraSync int, sectorOrder []byte) []byte {
trackSync := NYBBLE_TRACK_BYTES - 16*(preSync+NYBBLE_ADDRESS_BYTES+intraSync+NYBBLE_DATA_BYTES)
target := make([]byte, 0, NYBBLE_TRACK_BYTES)
target = appendSyncs(target, trackSync)
for s := byte(0); s < 16; s++ {
start := 256 * int(sectorOrder[s])
target = dosToNybbleSector(target, source[start:start+256], t, s, v, preSync, intraSync)
}
if len(target) != NYBBLE_TRACK_BYTES {
panic(fmt.Sprintf("Tracks should be %d bytes, go %d", NYBBLE_TRACK_BYTES, len(target)))
}
return target
}
func dos16ToNybbleTracks(source []byte, v byte, preSync, intraSync int, sectorOrder []byte) (tracks [][]byte, err error) {
if preSync+intraSync > MAX_PRE_INTRA_SYNC {
return nil, fmt.Errorf("preSync(%d) + intraSync(%d) cannot be more than %d bytes",
preSync, intraSync, MAX_PRE_INTRA_SYNC)
}
for t := byte(0); t < 35; t++ {
start := DOS_TRACK_BYTES * int(t)
trackBytes := source[start : start+DOS_TRACK_BYTES]
track := dos16ToNybbleTrack(trackBytes, t, v, preSync, intraSync, sectorOrder)
tracks = append(tracks, track)
}
return tracks, nil
}
func NybbleToDos16(nyb *Nybble, sectorOrder []byte) (bytes []byte, err error) {
// Save current disk position
pos := nyb.GetPos()
defer nyb.SetPos(pos)
var trackBytes [DOS_TRACK_BYTES]byte
for track := byte(0); track < NUM_TRACKS; track++ {
nyb.SetHalfTrack(track * 2)
seen := uint16(0)
for i := 0; i < 16; i++ {
sector, err := readOneSector(nyb)
if err != nil {
return nil, err
}
if sector.Sector > 15 {
return nil, fmt.Errorf("Found unexpected sector number on track %d: %d", track, sector.Sector)
}
if seen&(1<<sector.Sector) > 0 {
return nil, fmt.Errorf("Found sector %d twice on track %d", sector.Sector, track)
}
seen |= 1 << sector.Sector
start := 256 * int(sectorOrder[sector.Sector])
copy(trackBytes[start:start+256], sector.Data[:])
}
bytes = append(bytes, trackBytes[:]...)
}
return bytes, nil
}
// DiskToFile saves a Nybble disk to a given filename.
func DiskToFile(filename string, disk *Nybble) error {
ext := path.Ext(filename)
switch ext {
case ".nib":
var bytes []byte
for _, track := range disk.Tracks {
bytes = append(bytes, track...)
}
err := ioutil.WriteFile(filename, bytes, 0644)
if err != nil {
return err
}
return nil
case ".dsk", ".do", ".po":
sectorOrder := Dos33PhysicalToLogicalSectorMap
if ext == ".po" {
sectorOrder = ProDosPhysicalToLogicalSectorMap
}
bytes, err := NybbleToDos16(disk, sectorOrder)
if err != nil {
return err
}
if err = ioutil.WriteFile(filename, bytes, 0644); err != nil {
return err
}
return nil
}
return fmt.Errorf("Cannot save to file %s: unexpected extension %s", filename, ext)
}
// DiskFromFile loads a Nybble disk, given a filename.
// defaultVolume is the disk volume used if the file doesn't encode it, 0 for default (254).
func DiskFromFile(filename string, defaultVolume byte) (disk *Nybble, err error) {
volume := defaultVolume
if volume == 0 {
volume = DEFAULT_VOLUME
}
ext := path.Ext(filename)
bytes, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
switch ext {
case ".dsk", ".do", ".po":
sectorOrder := Dos33PhysicalToLogicalSectorMap
if ext == ".po" {
sectorOrder = ProDosPhysicalToLogicalSectorMap
}
if len(bytes) != DOS_DISK_BYTES {
return nil, fmt.Errorf("Expected %d bytes in file %s, got %d", DOS_DISK_BYTES, filename, len(bytes))
}
tracks, err := dos16ToNybbleTracks(bytes, volume, DEFAULT_PRESYNC, DEFAULT_INTRASYNC, sectorOrder)
if err != nil {
return nil, err
}
nyb := NewNybble(tracks)
return nyb, nil
case ".nib":
if len(bytes) != NYBBLE_DISK_BYTES {
return nil, fmt.Errorf("Expected %d bytes in file %s, got %d", NYBBLE_DISK_BYTES, filename, len(bytes))
}
var tracks [][]byte
for i := 0; i < NUM_TRACKS; i++ {
start := NYBBLE_TRACK_BYTES * i
tracks = append(tracks, bytes[start:start+NYBBLE_TRACK_BYTES])
}
nyb := NewNybble(tracks)
return nyb, nil
}
return nil, fmt.Errorf("Unknown suffix (not .dsk, .do, or .po): %s", filename)
}
type Sector struct {
Volume byte
Track byte
Sector byte
Data [256]byte
}
func read44(nyb *Nybble) byte {
return (nyb.Read()<<1 | 1) & nyb.Read()
}
func readOneSector(nyb *Nybble) (result Sector, err error) {
count := int(NYBBLE_TRACK_BYTES)
OUTER:
for ; count > 0; count-- {
if nyb.Read() != 0xD5 {
continue
}
if nyb.Read() != 0xAA {
continue
}
if nyb.Read() != 0x96 {
continue
}
result.Volume = read44(nyb)
result.Track = read44(nyb)
result.Sector = read44(nyb)
checksum := read44(nyb)
count -= 10
if checksum != result.Volume^result.Track^result.Sector {
continue
}
for nyb.Read() != 0xD5 {
count--
}
if nyb.Read() != 0xAA {
continue
}
if nyb.Read() != 0xAD {
continue
}
var raw [342]byte
xor := byte(0)
for i := 341; i >= 256; i-- {
count--
bi := Dos33readTable[nyb.Read()]
if bi < 0 {
continue OUTER
}
b := byte(bi) ^ xor
raw[i] = b
xor = b
}
for i := 0; i < 256; i++ {
count--
bi := Dos33readTable[nyb.Read()]
if bi < 0 {
continue OUTER
}
b := byte(bi) ^ xor
raw[i] = b
xor = b
}
if int(xor) != Dos33readTable[nyb.Read()] {
log.Print("Checksum error")
continue
}
result.Data = PostNybble(raw[:])
return result, nil
}
return result, fmt.Errorf("Unable to read sector")
}