diskstack 1.0.0__py3-none-any.whl

diskstack/_vendor/greaseweazle/codec/macintosh/mac_gcr.py

@@ -0,0 +1,238 @@
+# greaseweazle/codec/macintosh/mac_gcr.py
+#
+# The layout generated by master_track() matches as closely as possible a
+# raw dump I received of the first disk of the Italian release of stylewriter.
+# It differs slightly from the layout documented by MAME and generated by
+# FluxEngine, though I am sure in no important respects.
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from typing import List, Optional, Tuple
+
+import struct
+import itertools as it
+from bitarray import bitarray
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle import optimised
+from diskstack._vendor.greaseweazle.codec import codec
+from diskstack._vendor.greaseweazle.codec.ibm import ibm
+from diskstack._vendor.greaseweazle.track import MasterTrack, PLL, PLLTrack
+from diskstack._vendor.greaseweazle.flux import Flux, HasFlux
+
+default_revs = 1.3
+
+self_sync_bytes = b'\xff\x3f\xcf\xf3\xfc\xff'
+sector_sync_bytes = b'\xd5\xaa\x96' # 1101 0101 1010 1010 1001 0110
+data_sync_bytes   = b'\xd5\xaa\xad' # 1101 0101 1010 1010 1010 1101
+
+sector_sync = bitarray(endian='big')
+sector_sync.frombytes(sector_sync_bytes)
+
+data_sync = bitarray(endian='big')
+data_sync.frombytes(data_sync_bytes)
+
+seclen = 524
+enc_seclen = 703
+
+bad_sector = b'-=[BAD SECTOR]=-' * 32
+
+class MacGCR(codec.Codec):
+
+    time_per_rev = 0.2
+
+    verify_revs = default_revs
+
+    def __init__(self, cyl: int, head: int, config):
+        self.cyl, self.head = cyl, head
+        self.config = config
+        self.clock = config.clock
+        self.sector: List[Optional[bytes]]
+        self.sector = [None] * self.nsec
+        sec_map, pos = [-1] * self.nsec, 0
+        for i in range(self.nsec):
+            while sec_map[pos] != -1:
+                pos = (pos + 1) % self.nsec
+            sec_map[pos] = i
+            pos = (pos + config.interleave) % self.nsec
+        self.sec_map = sec_map
+        error.check(optimised.enabled,
+                    'Macintosh GCR requires optimised C extension')
+
+    @property
+    def nsec(self) -> int:
+        return self.config.secs
+
+    def summary_string(self) -> str:
+        nsec, nbad = self.nsec, self.nr_missing()
+        s = "Macintosh GCR (%d/%d sectors)" % (nsec - nbad, nsec)
+        return s
+
+    # private
+    def add(self, sec_id, data) -> None:
+        assert not self.has_sec(sec_id)
+        self.sector[sec_id] = data
+
+    def has_sec(self, sec_id: int) -> bool:
+        return self.sector[sec_id] is not None
+
+    def nr_missing(self) -> int:
+        return len([sec for sec in self.sector if sec is None])
+
+    def get_img_track(self) -> bytearray:
+        tdat = bytearray()
+        for sec in self.sector:
+            tdat += sec[12:] if sec is not None else bad_sector
+        return tdat
+
+    def set_img_track(self, tdat: bytes) -> int:
+        totsize = self.nsec * 512
+        if len(tdat) < totsize:
+            tdat += bytes(totsize - len(tdat))
+        for sec in range(self.nsec):
+            self.sector[sec] = bytes(12) + tdat[sec*512:(sec+1)*512]
+        return totsize
+
+    def decode_flux(self, track: HasFlux, pll: Optional[PLL]=None) -> None:
+        raw = PLLTrack(time_per_rev = self.time_per_rev,
+                       clock = self.clock, data = track, pll = pll)
+        bits, _ = raw.get_all_data()
+
+        for offs in bits.search(sector_sync):
+
+            if self.nr_missing() == 0:
+                break
+
+            # Decode header
+            offs += 3*8
+            sec = bits[offs:offs+5*8].tobytes()
+            if len(sec) != 5:
+                continue
+            hdr = optimised.decode_mac_gcr(sec)
+            sum = 0
+            for x in hdr:
+                sum ^= x
+            if sum != 0:
+                continue
+            cyl, sec_id, side, fmt = tuple(hdr[:4])
+            cyl |= (side & 1) << 6
+            side >>= 5
+            if (cyl != self.cyl or side != self.head or sec_id >= self.nsec):
+                print('T%d.%d: Ignoring unexpected sector '
+                      'C:%d H:%d R:%d F:0x%x'
+                      % (self.cyl, self.head, cyl, side, sec_id, fmt))
+                continue
+            if self.has_sec(sec_id):
+                continue
+
+            # Find data
+            offs += 5*8
+            dat_offs = list(bits[offs:offs+100*8].search(data_sync))
+            if len(dat_offs) != 1:
+                continue
+            offs += dat_offs[0]
+
+            # Decode data
+            offs += 4*8
+            sec = bits[offs:offs+703*8].tobytes()
+            if len(sec) != 703:
+                continue
+            sec = optimised.decode_mac_gcr(sec)
+            sec, csum = optimised.decode_mac_sector(sec)
+            if csum != 0:
+                continue
+
+            self.add(sec_id, sec)
+
+
+    def master_track(self) -> MasterTrack:
+
+        # Post-index track gap.
+        t = bytes([0x96] * 64) + self_sync_bytes * 20
+
+        for nr, sec_id in enumerate(self.sec_map):
+            sector = self.sector[sec_id]
+            data = (bytes(12) + bad_sector) if sector is None else sector
+            cyl, side = self.cyl, self.head
+            side = (side << 5) | (cyl >> 6)
+            cyl &= 0x3f
+            hdr = bytes([cyl, sec_id, side, self.config.format])
+            sum = 0
+            for x in hdr:
+                sum ^= x
+            t += self_sync_bytes * 6
+            t += sector_sync_bytes
+            t += optimised.encode_mac_gcr(hdr + bytes([sum]))
+            t += b'\xde\xaa\xff\xff'
+            t += self_sync_bytes
+            t += data_sync_bytes
+            t += optimised.encode_mac_gcr(bytes([sec_id]))
+            t += optimised.encode_mac_gcr(optimised.encode_mac_sector(data))
+            t += b'\xde\xaa\xff'
+
+        # Add the pre-index gap.
+        t += b'\xff' * 4
+        tlen = int((self.time_per_rev / self.clock)) & ~31
+        t += bytes([0x96] * (tlen//8-len(t)))
+
+        track = MasterTrack(bits = t, time_per_rev = self.time_per_rev)
+        track.verify = self
+        return track
+
+
+    def verify_track(self, flux):
+        readback_track = self.__class__(self.cyl, self.head, self.config)
+        readback_track.decode_flux(flux)
+        return (readback_track.nr_missing() == 0
+                and self.sector == readback_track.sector)
+
+
+class MacGCRDef(codec.TrackDef):
+
+    default_revs = default_revs
+
+    def __init__(self, format_name: str):
+        self.secs: Optional[int] = None
+        self.clock: Optional[float] = None
+        self.format: Optional[int] = None
+        self.interleave = 1
+        self.finalised = False
+
+    def add_param(self, key: str, val) -> None:
+        if key == 'secs':
+            val = int(val)
+            self.secs = val
+        elif key == 'clock':
+            val = float(val)
+            self.clock = val * 1e-6
+        elif key == 'format':
+            val = int(val, base=0)
+            error.check(0 <= val <= 255, '%s out of range' % key)
+            self.format = val
+        elif key == 'interleave':
+            val = int(val)
+            self.interleave = val
+        else:
+            raise error.Fatal('unrecognised track option %s' % key)
+
+    def finalise(self) -> None:
+        if self.finalised:
+            return
+        error.check(self.secs is not None,
+                    'number of sectors not specified')
+        error.check(self.clock is not None,
+                    'clock period not specified')
+        error.check(self.format is not None,
+                    'format byte not specified')
+        self.finalised = True
+
+    def mk_track(self, cyl: int, head: int) -> MacGCR:
+        return MacGCR(cyl, head, self)
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/codec/micropolis/micropolis.py

@@ -0,0 +1,233 @@
+# greaseweazle/codec/hp/micropolis.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+
+from typing import List, Optional
+
+import struct
+from bitarray import bitarray
+import crcmod.predefined
+import itertools as it
+from enum import Enum
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec import codec
+from diskstack._vendor.greaseweazle.codec.ibm.ibm import decode, encode, fm_encode, mfm_encode
+from diskstack._vendor.greaseweazle.track import MasterTrack, PLL, PLLTrack
+from diskstack._vendor.greaseweazle.flux import HasFlux
+
+default_revs = 1
+
+bad_sector = b'-=[BAD SECTOR]=-'
+
+mfm_sync = bitarray(endian='big')
+mfm_sync.frombytes(mfm_encode(encode(b'\x00\x00\x00\xff')))
+
+# Sector format is:
+#  40: 00 preamble
+#   1: FF sync
+#   2: track, sector
+#  10: padding/vendor
+# 256: payload
+#   1: checksum
+#   5: ecc [optional]
+#  NN: 00 postamble
+
+def micropolis_csum(dat):
+    y = 0
+    for x in dat:
+        if y > 255:
+            y -= 255
+        y += x
+    # Ignore carry on last addition
+    return y & 255
+
+class Micropolis(codec.Codec):
+
+    time_per_rev = 0.2
+
+    verify_revs: float = default_revs
+
+    def __init__(self, cyl: int, head: int, config):
+        self.clock = 2e-6
+        self.presync_bytes = 40
+        self.cyl, self.head = cyl, head
+        self.config = config
+        self.sector: List[Optional[bytes]]
+        self.sector = [None] * self.nsec
+
+    @property
+    def nsec(self) -> int:
+        return self.config.secs
+
+    @property
+    def img_bps(self) -> int:
+        return self.config.img_bps
+
+    def summary_string(self) -> str:
+        nsec, nbad = self.nsec, self.nr_missing()
+        s = "Micropolis (%d/%d sectors)" % (nsec - nbad, nsec)
+        return s
+
+    def bad_sector(self) -> bytes:
+        if self.img_bps == 256:
+            return bad_sector * 16
+        return b'\xff' + bytes(12) + bad_sector*16 + bytes(6)
+
+    # private
+    def add(self, sec_id, data) -> None:
+        assert not self.has_sec(sec_id)
+        self.sector[sec_id] = data
+
+    def has_sec(self, sec_id: int) -> bool:
+        return self.sector[sec_id] is not None
+
+    def nr_missing(self) -> int:
+        return len([sec for sec in self.sector if sec is None])
+
+    def get_img_track(self) -> bytearray:
+        tdat = bytearray()
+        for sec in self.sector:
+            tdat += sec if sec is not None else self.bad_sector()
+        return tdat
+
+    def set_img_track(self, tdat: bytes) -> int:
+        totsize = self.nsec * self.img_bps
+        if len(tdat) < totsize:
+            tdat += bytes(totsize - len(tdat))
+        for sec in range(self.nsec):
+            self.sector[sec] = tdat[sec*self.img_bps:(sec+1)*self.img_bps]
+        return totsize
+
+    def decode_flux(self, track: HasFlux, pll: Optional[PLL]=None) -> None:
+        flux = track.flux()
+        if flux.time_per_rev < self.time_per_rev / 2:
+            flux.identify_hard_sectors()
+        flux.cue_at_index()
+        raw = PLLTrack(time_per_rev = self.time_per_rev,
+                       clock = self.clock, data = flux, pll = pll)
+
+        for rev in range(len(raw.revolutions)):
+
+            if self.nr_missing() == 0:
+                break
+
+            bits, _ = raw.get_revolution(rev)
+
+            hardsector_bits = raw.revolutions[rev].hardsector_bits
+            if hardsector_bits is not None:
+                hardsector_bits = list(it.accumulate(hardsector_bits))
+            else:
+                hardsector_bits = [len(bits)*(i+1)//self.nsec
+                                   for i in range(self.nsec)]
+            error.check(len(hardsector_bits) == self.nsec,
+                        f'North Star: Unexpected number of sectors: '
+                        f'{len(hardsector_bits)}')
+            hardsector_bits = [0] + hardsector_bits
+
+            for hsec_id in range(self.nsec):
+
+                s, e = hardsector_bits[hsec_id], hardsector_bits[hsec_id+1]
+                # Skip first 50 cells (~100us) to avoid false sync
+                # Reference: Vector Micropolis Disk Controller Board Technical
+                # Information Manual, pp. 1-16.
+                s += 50
+                offs = bits[s:e].search(mfm_sync)
+                for off in offs:
+                    off += 3*16
+                    dat = decode(bits[s+off:s+off+275*16].tobytes())
+                    if len(dat) != 275:
+                        continue
+                    cyl, sec_id = dat[1], dat[2]
+                    if cyl != self.cyl or sec_id > self.nsec:
+                        print('T%d.%d: Ignoring unexpected sector C:%d R:%d'
+                              % (self.cyl, self.head, cyl, sec_id))
+                        continue
+                    if self.has_sec(sec_id):
+                        continue
+                    if micropolis_csum(dat[1:-6]) == dat[-6]:
+                        if hsec_id != sec_id:
+                            print(f'T{self.cyl, self.head}: Weird skew: '
+                                  f'hsec {hsec_id} contains sector {sec_id}')
+                        if self.img_bps == 256:
+                            self.add(sec_id, dat[13:13+256])
+                        else:
+                            self.add(sec_id, dat)
+                        break # We are done on this hard sector
+
+
+    def master_track(self) -> MasterTrack:
+
+        t = bytes()
+        slen = int((self.time_per_rev / self.clock / self.nsec / 16))
+
+        for sec_id in range(self.nsec):
+            s = encode(bytes(self.presync_bytes))
+            sector = self.sector[sec_id]
+            sector = self.bad_sector() if sector is None else sector
+            if len(sector) == 256:
+                dat = b'\xff' + bytes([self.cyl, sec_id]) + bytes(10)
+                dat += sector
+                dat += bytes([micropolis_csum(dat[1:])])
+            else:
+                if sector[0] != 0xff:
+                    print("T%u.%u: 275-byte sector doesn't start with FF sync"
+                          % (self.cyl, self.head))
+                dat = sector
+            s += encode(dat)
+            s += encode(bytes(slen - len(s)//2))
+            t += s
+
+        t = mfm_encode(t)
+
+        track = MasterTrack(bits = t, time_per_rev = self.time_per_rev,
+                            hardsector_bits = [slen*16] * self.nsec)
+        track.verify = self
+        return track
+
+
+    def verify_track(self, flux):
+        readback_track = self.__class__(self.cyl, self.head, self.config)
+        readback_track.decode_flux(flux)
+        return (readback_track.nr_missing() == 0
+                and self.sector == readback_track.sector)
+
+
+class MicropolisDef(codec.TrackDef):
+
+    default_revs = default_revs
+
+    def __init__(self, format_name: str):
+        self.secs: Optional[int] = None
+        self.img_bps: Optional[int] = None
+        self.finalised = False
+
+    def add_param(self, key: str, val) -> None:
+        if key == 'secs':
+            val = int(val)
+            self.secs = val
+        elif key == 'img_bps':
+            val = int(val)
+            self.img_bps = val
+            error.check(val in [256, 275], f'bad img_bps {val}')
+        else:
+            raise error.Fatal('unrecognised track option %s' % key)
+
+    def finalise(self) -> None:
+        if self.finalised:
+            return
+        error.check(self.secs is not None,
+                    'number of sectors not specified')
+        error.check(self.img_bps is not None,
+                    'img_bps not specified')
+        self.finalised = True
+
+    def mk_track(self, cyl: int, head: int) -> Micropolis:
+        return Micropolis(cyl, head, self)
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/codec/northstar/northstar.py

@@ -0,0 +1,210 @@
+# greaseweazle/codec/hp/northstar.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+
+from typing import List, Optional
+
+import struct
+from bitarray import bitarray
+import crcmod.predefined
+import itertools as it
+from enum import Enum
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec import codec
+from diskstack._vendor.greaseweazle.codec.ibm.ibm import decode, encode, fm_encode, mfm_encode
+from diskstack._vendor.greaseweazle.track import MasterTrack, PLL, PLLTrack
+from diskstack._vendor.greaseweazle.flux import HasFlux
+
+default_revs = 1
+
+bad_sector = b'-=[BAD SECTOR]=-'
+
+mfm_sync = bitarray(endian='big')
+mfm_sync.frombytes(mfm_encode(encode(b'\x00\xfb')))
+
+fm_sync = bitarray(endian='big')
+fm_sync.frombytes(fm_encode(encode(b'\x00\xfb')))
+
+def csum(dat):
+    y = 0
+    for x in dat:
+        y ^= x
+        y = ((y << 1) | (y >> 7)) & 255
+    return y
+
+class Mode(Enum):
+    FM, MFM = range(2)
+    def __str__(self):
+        NAMES = [ 'North Star FM', 'North Star MFM' ]
+        return f'{NAMES[self.value]}'
+
+class NorthStar(codec.Codec):
+
+    time_per_rev = 0.2
+
+    verify_revs: float = default_revs
+
+    def __init__(self, cyl: int, head: int, config):
+        if config.mode is Mode.FM:
+            self.clock = 4e-6
+            self.bps = 256
+            self.sync = fm_sync
+            self.presync_bytes = 17
+            self.sync_bytes = 1
+        else:
+            self.clock = 2e-6
+            self.bps = 512
+            self.sync = mfm_sync
+            self.presync_bytes = 34
+            self.sync_bytes = 2
+        self.cyl, self.head = cyl, head
+        self.config = config
+        self.sector: List[Optional[bytes]]
+        self.sector = [None] * self.nsec
+
+    @property
+    def nsec(self) -> int:
+        return self.config.secs
+
+    def summary_string(self) -> str:
+        nsec, nbad = self.nsec, self.nr_missing()
+        s = "%s (%d/%d sectors)" % (self.config.mode, nsec - nbad, nsec)
+        return s
+
+    # private
+    def add(self, sec_id, data) -> None:
+        assert not self.has_sec(sec_id)
+        self.sector[sec_id] = data
+
+    def has_sec(self, sec_id: int) -> bool:
+        return self.sector[sec_id] is not None
+
+    def nr_missing(self) -> int:
+        return len([sec for sec in self.sector if sec is None])
+
+    def get_img_track(self) -> bytearray:
+        tdat = bytearray()
+        for sec in self.sector:
+            tdat += sec if sec is not None else bad_sector * (self.bps//16)
+        return tdat
+
+    def set_img_track(self, tdat: bytes) -> int:
+        totsize = self.nsec * self.bps
+        if len(tdat) < totsize:
+            tdat += bytes(totsize - len(tdat))
+        for sec in range(self.nsec):
+            self.sector[sec] = tdat[sec*self.bps:(sec+1)*self.bps]
+        return totsize
+
+    def decode_flux(self, track: HasFlux, pll: Optional[PLL]=None) -> None:
+        flux = track.flux()
+        if flux.time_per_rev < self.time_per_rev / 2:
+            flux.identify_hard_sectors()
+        flux.cue_at_index()
+        raw = PLLTrack(time_per_rev = self.time_per_rev,
+                       clock = self.clock, data = flux, pll = pll)
+
+        for rev in range(len(raw.revolutions)):
+
+            if self.nr_missing() == 0:
+                break
+
+            bits, _ = raw.get_revolution(rev)
+
+            hardsector_bits = raw.revolutions[rev].hardsector_bits
+            if hardsector_bits is not None:
+                hardsector_bits = list(it.accumulate(hardsector_bits))
+            else:
+                hardsector_bits = [len(bits)*(i+1)//self.nsec
+                                   for i in range(self.nsec)]
+            error.check(len(hardsector_bits) == self.nsec,
+                        f'North Star: Unexpected number of sectors: '
+                        f'{len(hardsector_bits)}')
+            hardsector_bits = [0] + hardsector_bits
+
+            for sec_id in range(self.nsec):
+
+                if self.has_sec(sec_id):
+                    continue
+
+                s, e = hardsector_bits[sec_id], hardsector_bits[sec_id+1]
+                offs = bits[s:e].search(self.sync)
+                if (off := next(offs, None)) is None:
+                    continue
+                off += (1 + self.sync_bytes) * 16
+                data = decode(bits[s+off:s+off+(self.bps+1)*16].tobytes())
+                if csum(data[:-1]) == data[-1]:
+                    self.add(sec_id, data[:-1])
+
+
+    def master_track(self) -> MasterTrack:
+
+        t = bytes()
+        slen = int((self.time_per_rev / self.clock / self.nsec / 16))
+
+        for sec_id in range(self.nsec):
+            s  = encode(bytes(self.presync_bytes))
+            s += encode(b'\xfb' * self.sync_bytes)
+            sector = self.sector[sec_id]
+            data = bad_sector*(self.bps//16) if sector is None else sector
+            s += encode(data + bytes([csum(data)]))
+            s += encode(bytes(slen - len(s)//2))
+            t += s
+
+        t = mfm_encode(t) if self.config.mode is Mode.MFM else fm_encode(t)
+
+        track = MasterTrack(bits = t, time_per_rev = self.time_per_rev,
+                            hardsector_bits = [slen*16] * self.nsec)
+        track.verify = self
+        return track
+
+
+    def verify_track(self, flux):
+        readback_track = self.__class__(self.cyl, self.head, self.config)
+        readback_track.decode_flux(flux)
+        return (readback_track.nr_missing() == 0
+                and self.sector == readback_track.sector)
+
+
+class NorthStarDef(codec.TrackDef):
+
+    default_revs = default_revs
+
+    def __init__(self, format_name: str):
+        self.mode: Optional[Mode] = None
+        self.secs: Optional[int] = None
+        self.finalised = False
+
+    def add_param(self, key: str, val) -> None:
+        if key == 'secs':
+            val = int(val)
+            self.secs = val
+        elif key == 'mode':
+            if val == 'fm':
+                self.mode = Mode.FM
+            elif val == 'mfm':
+                self.mode = Mode.MFM
+            else:
+                raise error.Fatal('unrecognised mode %s' % val)
+        else:
+            raise error.Fatal('unrecognised track option %s' % key)
+
+    def finalise(self) -> None:
+        if self.finalised:
+            return
+        error.check(self.secs is not None,
+                    'number of sectors not specified')
+        error.check(self.mode is not None,
+                    'mode not specified')
+        self.finalised = True
+
+    def mk_track(self, cyl: int, head: int) -> NorthStar:
+        return NorthStar(cyl, head, self)
+
+
+# Local variables:
+# python-indent: 4
+# End: