diskstack 1.0.0__py3-none-any.whl

diskstack/_vendor/greaseweazle/data/diskdefs_zx.cfg

@@ -0,0 +1,245 @@
+# prefix: zx.
+
+# Betadisk TR-DOS
+disk trdos.ds80
+    cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 16
+        bps = 256
+        h = 0
+    end
+end
+
+# Quorum (ZX Spectrum clone) running CP/M-80
+disk quorum.ds80
+    cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 5
+        bps = 1024
+    end
+end
+
+# Didaktik D80 
+disk d80.ds80
+    cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 9
+        bps = 512
+    end
+end
+
+#Timex FDD 3/3000
+disk fdd3000.ss40
+ cyls = 40
+    heads = 1
+    tracks 0-39 ibm.mfm
+        secs = 16
+        bps = 256
+        id = 0
+        rate = 250
+	h = 0
+    end
+end
+
+disk fdd3000.ds80
+ cyls = 80
+    heads = 2
+    tracks 0-79 ibm.mfm
+        secs = 16
+        bps = 256
+        id = 0
+        rate = 250
+	h = 1
+    end
+    tracks 0-79 ibm.mfm
+        secs = 16
+        bps = 256
+        id = 0
+        rate = 250
+	h = 0
+    end
+end
+
+# Kempston Disk Interface
+disk kempston.ss40
+ cyls = 40
+    heads = 1
+    tracks * ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	id=0
+    end
+end
+
+disk kempston.ds80
+ cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	id=0
+    end
+end
+
+# MGT +D
+disk plusd.ds80
+    cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 10
+        bps = 512
+    end
+end
+
+#ZX Spectrum Opus Discovery
+disk opus.ss40
+ cyls = 40
+    heads = 1
+    tracks * ibm.mfm
+        secs = 18
+        bps = 256
+        id = 0
+        rate = 250
+	cskew = 13
+	interleave=13
+	iam = no
+    end
+end
+
+disk opus.ds80
+ cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 18
+        bps = 256
+        id = 0
+        rate = 250
+	cskew = 13
+	interleave=13
+	iam = no
+    end
+end
+
+# ZX Spectrum +3DOS
+disk 3dos.ss40
+ cyls = 40
+    heads = 1
+    tracks * ibm.mfm
+        secs = 9
+        bps = 512
+        rate = 250
+    end
+end
+
+disk 3dos.ds80
+ cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 9
+        bps = 512
+        rate = 250
+    end
+end
+
+# Rocky Gush
+disk rocky.ss40
+ cyls = 40
+    heads = 1
+    tracks 0-79 ibm.mfm
+        secs = 5
+        bps = 1024
+        id = 0
+        rate = 250
+	h = 0
+    end
+end
+
+disk rocky.ds80
+ cyls = 80
+    heads = 2
+    tracks 0-79 ibm.mfm
+        secs = 5
+        bps = 1024
+        id = 0
+        rate = 250
+	h = 1
+    end
+	tracks 0-79 ibm.mfm
+        secs = 5
+        bps = 1024
+        id = 0
+        rate = 250
+	h = 0
+    end
+end
+
+# Turbodrive
+disk turbodrive.ds40
+ cyls = 40
+    heads = 2
+    tracks 0-39 ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	interleave = 5
+	cskew = 5
+	h = 1
+    end
+	tracks 0-39 ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	interleave = 5
+	cskew = 5
+	h = 0
+    end
+end
+
+disk turbodrive.ds80
+ cyls = 80
+    heads = 2
+    tracks 0-79 ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	interleave = 5
+	cskew = 5
+	h = 1
+    end
+	tracks 0-79 ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	interleave = 5
+	cskew = 5
+	h = 0
+    end
+end
+
+# Watford SPDOS
+disk watford.ss40
+ cyls = 40
+    heads = 1
+    tracks * ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	id=0
+    end
+end
+
+disk watford.ds80
+ cyls = 80
+    heads = 2
+    tracks * ibm.mfm
+        secs = 10
+        bps = 512
+        rate = 250
+	id=0
+    end
+end

diskstack/_vendor/greaseweazle/error.py

@@ -0,0 +1,19 @@
+# greaseweazle/error.py
+#
+# Error management and reporting.
+#
+# 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>.
+
+class Fatal(Exception):
+    pass
+
+def check(pred, desc):
+    if not pred:
+        raise Fatal(desc)
+    
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/flux.py

@@ -0,0 +1,315 @@
+# greaseweazle/flux.py
+#
+# 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 __future__ import annotations
+from typing import List, Optional, Protocol
+
+from diskstack._vendor.greaseweazle import error
+
+class HasFlux(Protocol):
+    def summary_string(self) -> str:
+        ...
+    def flux(self) -> Flux:
+        ...
+    def flux_for_writeout(self, cue_at_index) -> WriteoutFlux:
+        ...
+
+class Flux:
+
+    _ticks_per_rev: float
+    
+    def __init__(self,
+                 index_list: List[float],
+                 flux_list: List[float],
+                 sample_freq: float,
+                 index_cued = True) -> None:
+        self.index_list = index_list
+        self.sector_list: Optional[List[List[float]]] = None
+        self.list = flux_list
+        self.sample_freq = sample_freq
+        self.splice: Optional[float] = None
+        self.index_cued = index_cued
+
+
+    def __str__(self) -> str:
+        s = "\nFlux: %.2f MHz" % (self.sample_freq*1e-6)
+        if self.index_cued: s += ", Index-Cued"
+        s += ("\n Total: %u samples, %.2fms\n"
+              % (len(self.list), sum(self.list)*1000/self.sample_freq))
+        for rev, t in enumerate(self.index_list):
+            s += " Revolution %u: %.2fms\n" % (rev, t*1000/self.sample_freq)
+            if self.sector_list:
+                for sec, t in enumerate(self.sector_list[rev]):
+                    s += ("    Sector %u: %.2fms\n"
+                          % (sec, t*1000/self.sample_freq))
+        return s[:-1]
+
+
+    def summary_string(self) -> str:
+        return ("Raw Flux (%u flux in %.2fms)"
+                % (len(self.list), sum(self.list)*1000/self.sample_freq))
+
+
+    def identify_hard_sectors(self) -> None:
+        if self.sector_list is not None:
+            return
+        error.check(len(self.index_list) > 3,
+                    "Not enough index marks for a hard-sectored track")
+        self.cue_at_index()
+        x = [self.index_list[0], self.index_list[2]]
+        x.sort()
+        thresh = x[1] * 3 / 4
+        ticks_to_index: float = 0
+        short_ticks: float = 0
+        sectors: List[float] = []
+        index_list = self.index_list
+        self.index_list = []
+        self.sector_list = []
+        short_count = 0
+        for t in index_list:
+            is_short = (t < thresh)
+            if is_short:
+                short_ticks += t
+                short_count += 1
+            # Latch an index when we see two short pulses, or a long pulse
+            # following at least one short pulse.
+            if short_count != 0 and (short_count > 1 or not is_short):
+                ticks_to_index += short_ticks
+                sectors.append(short_ticks)
+                self.index_list.append(ticks_to_index)
+                self.sector_list.append(sectors)
+                sectors = []
+                short_ticks = ticks_to_index = short_count = 0
+            if not is_short:
+                ticks_to_index += t
+                sectors.append(t)
+        error.check(len(self.index_list) > 0,
+                    "No hard-sector index mark found")
+        self.index_cued = (
+            (len(self.index_list) >= 2) and
+            (len(self.sector_list[0]) == len(self.sector_list[1])))
+
+
+    def append(self, flux: Flux) -> None:
+        # Scale the new flux if required, to match existing sample frequency.
+        # This will result in floating-point flux values.
+        if self.sample_freq == flux.sample_freq:
+            f_list, i_list = flux.list, flux.index_list
+        else:
+            factor = self.sample_freq / flux.sample_freq
+            f_list = [x*factor for x in flux.list]
+            i_list = [x*factor for x in flux.index_list]
+        # Any trailing flux is incorporated into the first revolution of
+        # the appended flux.
+        rev0 = i_list[0] + sum(self.list) - sum(self.index_list)
+        self.index_list += [rev0] + i_list[1:]
+        self.list += f_list
+        # TODO: Work with hard-sectored disks
+        self.sector_list = None
+
+
+    def cue_at_index(self) -> None:
+
+        if self.index_cued:
+            return
+
+        error.check(len(self.index_list) >= 2,
+                    '''\
+                    Not enough revolutions of flux data to cue at index.
+                    Try dumping more revolutions (larger --revs value).''')
+
+        # Clip the initial partial revolution.
+        to_index = self.index_list[0]
+        for i in range(len(self.list)):
+            to_index -= self.list[i]
+            if to_index < 0:
+                break
+        if to_index < 0:
+            self.list = [-to_index] + self.list[i+1:]
+        else: # we ran out of flux
+            self.list = []
+        self.index_list = self.index_list[1:]
+        self.index_cued = True
+        if self.sector_list:
+            self.sector_list = self.sector_list[1:]
+
+
+    def reverse(self) -> None:
+
+        assert self.sector_list is None
+
+        was_index_cued = self.index_cued
+        flux_sum = sum(self.list)
+
+        self.index_cued = False
+        self.list.reverse()
+        self.index_list.reverse()
+
+        to_index = flux_sum - sum(self.index_list)
+        if to_index <= 0:
+            if to_index < 0:
+                self.list.insert(0, -to_index)
+                flux_sum += -to_index
+            self.index_list = self.index_list[1:]
+            self.index_cued = True
+        else:
+            self.index_list = [to_index] + self.index_list[:-1]
+
+        if was_index_cued:
+            self.index_list.append(flux_sum - sum(self.index_list))
+
+
+    def set_nr_revs(self, revs:int) -> None:
+
+        self.cue_at_index()
+        error.check(self.index_list,
+                    'Need at least one revolution to adjust # revolutions')
+
+        if len(self.index_list) > revs:
+            self.index_list = self.index_list[:revs]
+            if self.sector_list:
+                self.sector_list = self.sector_list[:revs]
+            to_index = sum(self.index_list)
+            for i in range(len(self.list)):
+                to_index -= self.list[i]
+                if to_index < 0:
+                    self.list = self.list[:i]
+                    break
+
+        while len(self.index_list) < revs:
+            nr = min(revs - len(self.index_list), len(self.index_list))
+            to_index = sum(self.index_list[:nr])
+            l = self.list
+            for i in range(len(l)):
+                to_index -= l[i]
+                if to_index < 0:
+                    to_index += l[i]
+                    l = l[:i]
+                    break
+            if self.list:
+                self.list = l + [to_index + self.list[0]] + self.list[1:]
+            self.index_list = self.index_list[:nr] + self.index_list
+            if self.sector_list:
+                self.sector_list = self.sector_list[:nr] + self.sector_list
+
+    def flux_for_writeout(self, cue_at_index) -> WriteoutFlux:
+
+        # Splice at index unless we know better.
+        splice = 0 if self.splice is None else self.splice
+
+        error.check(self.index_cued,
+                    "Cannot write non-index-cued raw flux")
+        error.check(splice == 0 or len(self.index_list) > 1,
+                    "Cannot write single-revolution unaligned raw flux")
+        splice_at_index = (splice == 0)
+
+        # Copy the required amount of flux to a fresh list.
+        flux_list = []
+        to_index = self.index_list[0]
+        remain = to_index + splice
+        for f in self.list:
+            if f > remain:
+                break
+            flux_list.append(f)
+            remain -= f
+
+        if not cue_at_index:
+            # We will write more than one revolution and terminate the
+            # second revolution at the splice. Extend the start of the write
+            # with "safe" 4us sample values, in case the drive motor is a
+            # little fast.
+            if remain > 0:
+                flux_list.append(remain)
+            prepend = max(round(to_index/10 - splice), 0)
+            if prepend != 0:
+                four_us = max(self.sample_freq * 4e-6, 1)
+                flux_list = [four_us]*round(prepend/four_us) + flux_list
+            splice_at_index = False
+        elif splice_at_index:
+            # Extend with "safe" 4us sample values, to avoid unformatted area
+            # at end of track if drive motor is a little slow.
+            four_us = max(self.sample_freq * 4e-6, 1)
+            if remain > four_us:
+                flux_list.append(remain)
+            for i in range(round(to_index/(10*four_us))):
+                flux_list.append(four_us)
+        elif remain > 0:
+            # End the write exactly where specified.
+            flux_list.append(remain)
+
+        return WriteoutFlux(to_index, flux_list, self.sample_freq,
+                            index_cued = cue_at_index,
+                            terminate_at_index = splice_at_index)
+
+
+
+    def flux(self) -> Flux:
+        return self
+
+
+    def scale(self, factor) -> None:
+        """Scale up all flux and index timings by specified factor."""
+        self.sample_freq /= factor
+
+
+    @property
+    def ticks_per_rev(self) -> float:
+        """Mean time between index pulses, in sample ticks"""
+        try:
+            index_list = self.index_list
+            if not self.index_cued:
+                index_list = index_list[1:]
+            ticks_per_rev = sum(index_list) / len(index_list)
+        except:
+            ticks_per_rev = self._ticks_per_rev
+        return ticks_per_rev
+
+
+    @property
+    def time_per_rev(self) -> float:
+        """Mean time between index pulses, in seconds (float)"""
+        return self.ticks_per_rev / self.sample_freq
+
+
+class WriteoutFlux:
+
+    def __init__(
+            self,
+            ticks_to_index: float,
+            flux_list: List[float],
+            sample_freq: float,
+            index_cued: bool,
+            terminate_at_index: bool
+    ) -> None:
+        self.ticks_to_index = ticks_to_index
+        self.list = flux_list
+        self.sample_freq = sample_freq
+        self.index_cued = index_cued
+        self.terminate_at_index = terminate_at_index
+
+
+    def __str__(self) -> str:
+        s = ("\nWriteoutFlux: %.2f MHz, %.2fms to index, %s\n"
+             " Total: %u samples, %.2fms"
+             % (self.sample_freq*1e-6,
+                self.ticks_to_index*1000/self.sample_freq,
+                ("Write all", "Terminate at index")[self.terminate_at_index],
+                len(self.list), sum(self.list)*1000/self.sample_freq))
+        return s
+
+
+    def summary_string(self) -> str:
+        s = ("Flux: %.1fms period, %.1f ms total, %s"
+             % (self.ticks_to_index*1000/self.sample_freq,
+                sum(self.list)*1000/self.sample_freq,
+                ("Write all", "Terminate at index")[self.terminate_at_index]))
+        return s
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/a2r.py

@@ -0,0 +1,133 @@
+# greaseweazle/image/a2r.py
+#
+# Applesauce 3.x image format.
+#
+# 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 Dict, Tuple, Optional, List
+
+import struct
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.flux import Flux
+from .image import Image
+
+class A2RCapType:
+    timing  = 1
+    bits    = 2
+    xtiming = 3
+
+
+class A2RTrack:
+
+    def __init__(self, cyl: int, head: int, ps_per_tick: int):
+        self.cyl, self.head = cyl, head
+        self.sample_freq = 1e12 / ps_per_tick
+        self.caps: List[bytes] = list()
+
+
+    def add_cap(self, cap) -> None:
+        self.caps.append(cap)
+
+
+    def best_cap(self) -> bytes:
+        # Look for a trace with two index pulses. This is correct for the
+        # claimed 2.25 revolutions of an index-cued xtiming capture.
+        for dat in self.caps:
+            if dat[4] == 2:
+                return dat
+        return self.caps[-1]
+
+
+    def flux(self) -> Flux:
+        dat = self.best_cap()
+
+        # Decode the index list.
+        nidx = dat[4]
+        i = 5+nidx*4
+        index_list = list(struct.unpack(f'<{nidx}I', dat[5:i]))
+        for i in range(len(index_list)-1, 0, -1):
+            index_list[i] -= index_list[i-1]
+        ncap, = struct.unpack('<I', dat[i:i+4])
+        i += 4
+
+        # Decode the flux list.
+        flux_list: List[float] = []
+        acc = 0
+        for f in dat[i:i+ncap]:
+            acc += f
+            if f != 255:
+                flux_list.append(acc)
+                acc = 0
+        if acc != 0:
+            flux_list.append(acc)
+
+        flux = Flux(index_list, flux_list, self.sample_freq)
+        return flux
+
+
+class A2R(Image):
+
+    read_only = True
+
+
+    def __init__(self, name: str, _fmt) -> None:
+        self.to_track: Dict[Tuple[int,int], A2RTrack] = dict()
+        self.filename = name
+
+
+    def process_rwcp(self, dat: bytes) -> None:
+
+        ps_per_tick, = struct.unpack('<I', dat[1:5])
+        i = 16
+
+        while dat[i] == ord('C'):
+
+            start = i
+
+            # Basic decoding, sufficient to skip unwanted capture types.
+            cap, loc, nidx = struct.unpack('<BHB', dat[i+1:i+5])
+            cyl, head = loc>>1, loc&1
+            i += 5 + nidx*4
+            ncap, = struct.unpack('<I', dat[i:i+4])
+            i += 4 + ncap
+
+            # Store away (x)timing captures for future decode.
+            if cap != A2RCapType.xtiming and cap != A2RCapType.timing:
+                continue
+            if not (cyl, head) in self.to_track:
+                t = A2RTrack(cyl, head, ps_per_tick)
+                self.to_track[cyl, head] = t
+            else:
+                t = self.to_track[cyl, head]
+            t.add_cap(dat[start:i])
+    
+
+    def from_bytes(self, dat: bytes) -> None:
+
+        error.check(dat[:8] == b'A2R3\xff\x0a\x0d\x0a',
+                    'A2R: Invalid signature')
+        dat = dat[8:]
+
+        # Extract the RWCP chunk(s).
+        while len(dat) > 8:
+            id, sz = struct.unpack('<4sI', dat[:8])
+            dat = dat[8:]
+            if id == b'RWCP':
+                self.process_rwcp(dat)
+            dat = dat[sz:]
+
+
+    def get_track(self, cyl: int, side: int) -> Optional[Flux]:
+        if not (cyl, side) in self.to_track:
+            return None
+        track = self.to_track[cyl, side]
+        return track.flux()
+
+
+# Local variables:
+# python-indent: 4
+# End: