diskstack 1.0.0__py3-none-any.whl

diskstack/_vendor/greaseweazle/image/kryoflux.py

@@ -0,0 +1,304 @@
+# greaseweazle/image/kryoflux.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 typing import Optional
+
+import struct, re, math, os, datetime
+import itertools as it
+
+from diskstack._vendor.greaseweazle import __version__
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.flux import Flux
+from .image import Image, ImageOpts, OptDict
+
+def_mck = 18432000 * 73 / 14 / 2
+def_sck = def_mck / 2
+
+class Op:
+    Nop1  =  8
+    Nop2  =  9
+    Nop3  = 10
+    Ovl16 = 11
+    Flux3 = 12
+    OOB   = 13
+
+class OOB:
+    StreamInfo =  1
+    Index      =  2
+    StreamEnd  =  3
+    KFInfo     =  4
+    EOF        = 13
+
+class KFOpts(ImageOpts):
+    """sck: Sample clock to use for flux timings.
+    Suffix 'm' for MHz. For example: sck=72m
+    revs: Number of revolutions to output per track.
+    """
+
+    w_settings = [ 'sck', 'revs' ]
+
+    def __init__(self) -> None:
+        self._sck: float = def_sck
+        self._revs: Optional[int] = None
+
+    @property
+    def sck(self) -> float:
+        return self._sck
+    @sck.setter
+    def sck(self, sck: str):
+        factor = 1e0
+        if sck.lower().endswith('m'):
+            sck = sck[:-1]
+            factor = 1e6
+        try:
+            self._sck = float(sck) * factor
+        except ValueError:
+            raise error.Fatal("Kryoflux: Bad sck value: '%s'\n" % sck)
+
+    @property
+    def revs(self) -> Optional[int]:
+        return self._revs
+    @revs.setter
+    def revs(self, revs: str) -> None:
+        try:
+            self._revs = int(revs)
+            if self._revs < 1:
+                raise ValueError
+        except ValueError:
+            raise error.Fatal("Kryoflux: Invalid revs: '%s'" % revs)
+
+
+class KryoFlux(Image):
+
+    def __init__(self, name: str, _fmt) -> None:
+        m = re.search(r'\d{2}\.[01]\.raw$', name, flags=re.IGNORECASE)
+        error.check(
+            m is not None,
+            '''\
+            Bad Kryoflux image name pattern '%s'
+            Name pattern must be path/to/nameNN.N.raw (N is a digit)'''
+            % name)
+        assert m is not None # mypy
+        self.basename = name[:m.start()]
+        self.filename = name
+        self.opts = KFOpts()
+
+
+    @classmethod
+    def from_file(cls, name: str, _fmt, opts: OptDict) -> Image:
+        # Check that the specified raw file actually exists.
+        with open(name, 'rb') as _:
+            pass
+        obj = cls(name, _fmt)
+        obj.apply_r_opts(opts)
+        return obj
+
+
+    def get_track(self, cyl, side):
+
+        name = self.basename + '%02d.%d.raw' % (cyl, side)
+        try:
+            with open(name, 'rb') as f:
+                dat = f.read()
+        except FileNotFoundError:
+            return None
+
+        # Parse the index-pulse stream positions and KFInfo blocks.
+        index, idx = [], 0
+        sck, ick = self.opts.sck, self.opts.sck/8
+        while idx < len(dat):
+            op = dat[idx]
+            if op == Op.OOB:
+                oob_op, oob_sz = struct.unpack('<BH', dat[idx+1:idx+4])
+                idx += 4
+                if oob_op == OOB.Index:
+                    pos, = struct.unpack('<I', dat[idx:idx+4])
+                    index.append(pos)
+                elif oob_op == OOB.EOF:
+                    break
+                elif oob_op == OOB.KFInfo:
+                    info = dat[idx:idx+oob_sz-1].decode('utf-8', 'ignore')
+                    m = re.search(r'sck=([^,]+)', info)
+                    if m is not None:
+                        sck = float(m.group(1))
+                    m = re.search(r'ick=([^,]+)', info)
+                    if m is not None:
+                        ick = float(m.group(1))
+                idx += oob_sz
+            elif op == Op.Nop3 or op == Op.Flux3:
+                idx += 3
+            elif op <= 7 or op == Op.Nop2:
+                idx += 2
+            else:
+                idx += 1
+
+        # Build the flux and index lists for the Flux object.
+        flux, flux_list, index_list = [], [], []
+        val, index_idx, stream_idx, idx = 0, 0, 0, 0
+        while idx < len(dat):
+            if index_idx < len(index) and stream_idx >= index[index_idx]:
+                # We've passed an index marker.
+                index_list.append(sum(flux))
+                flux_list += flux
+                flux = []
+                index_idx += 1
+            op = dat[idx]
+            if op <= 7:
+                # Flux2
+                val += (op << 8) + dat[idx+1]
+                flux.append(val)
+                val = 0
+                stream_idx += 2
+                idx += 2
+            elif op <= 10:
+                # Nop1, Nop2, Nop3
+                nr = op-7
+                stream_idx += nr
+                idx += nr
+            elif op == Op.Ovl16:
+                # Ovl16
+                val += 0x10000
+                stream_idx += 1
+                idx += 1
+            elif op == Op.Flux3:
+                # Flux3
+                val += (dat[idx+1] << 8) + dat[idx+2]
+                flux.append(val)
+                val = 0
+                stream_idx += 3
+                idx += 3
+            elif op == Op.OOB:
+                # OOB
+                oob_op, oob_sz = struct.unpack('<BH', dat[idx+1:idx+4])
+                idx += 4
+                if oob_op == OOB.StreamInfo or oob_op == OOB.StreamEnd:
+                    pos, = struct.unpack('<I', dat[idx:idx+4])
+                    error.check(pos == stream_idx,
+                                "Out-of-sync during KryoFlux stream read")
+                elif oob_op == OOB.EOF:
+                    break
+                idx += oob_sz
+            else:
+                # Flux1
+                val += op
+                flux.append(val)
+                val = 0
+                stream_idx += 1
+                idx += 1
+
+        flux_list += flux
+
+        # Crop partial first revolution.
+        if len(index_list) > 1:
+            short_index, index_list = index_list[0], index_list[1:]
+            flux = 0
+            for i in range(len(flux_list)):
+                if flux >= short_index:
+                    break
+                flux += flux_list[i]
+            flux_list = flux_list[i:]
+
+        return Flux(index_list, flux_list, sck)
+
+
+    def emit_track(self, cyl, side, track):
+        """Converts @track into a KryoFlux stream file."""
+
+        # Check if we should insert an OOB record for the next index mark.
+        def check_index(prev_flux):
+            nonlocal index_idx, dat
+            if index_idx < len(index) and total >= index[index_idx]:
+                dat += struct.pack('<2BH3I', Op.OOB, OOB.Index, 12,
+                                   stream_idx,
+                                   round(index[index_idx] - total + prev_flux),
+                                   round(index[index_idx]/8))
+                index_idx += 1
+
+        # Emit a resampled flux value to the KryoFlux data stream.
+        def emit(f):
+            nonlocal stream_idx, dat, total
+            while f >= 0x10000:
+                stream_idx += 1
+                dat.append(Op.Ovl16)
+                f -= 0x10000
+                total += 0x10000
+                check_index(0x10000)
+            if f >= 0x800:
+                stream_idx += 3
+                dat += struct.pack('>BH', Op.Flux3, f)
+            elif Op.OOB < f < 0x100:
+                stream_idx += 1
+                dat.append(f)
+            else:
+                stream_idx += 2
+                dat += struct.pack('>H', f)
+            total += f
+            check_index(f)
+
+        flux = track.flux()
+        sck = self.opts.sck
+
+        # HxC crashes or fails to load non-index-cued stream files.
+        # So let's give it what it wants.
+        flux.cue_at_index()
+
+        if self.opts.revs is not None:
+            flux.set_nr_revs(self.opts.revs)
+
+        factor = sck / flux.sample_freq
+        dat = bytearray()
+
+        now = datetime.datetime.now()
+        host_date = now.strftime('%Y.%m.%d')
+        host_time = now.strftime('%H:%M:%S')
+        info = (f'name=Greaseweazle, version={__version__}, '
+                f'host_date={host_date}, host_time={host_time}, '
+                f'sck={sck:.7f}, ick={sck/8:.7f}')
+        dat += struct.pack('<2BH', Op.OOB, OOB.KFInfo, len(info)+1)
+        dat += info.encode('utf-8') + bytes(1)
+
+        # Start the data stream with a dummy index if our Flux is index cued.
+        if flux.index_cued:
+            dat += struct.pack('<2BH3I', Op.OOB, OOB.Index, 12, 0, 0, 0)
+
+        # Prefix-sum list of resampled index timings.
+        index = list(it.accumulate(map(lambda x: x*factor, flux.index_list)))
+        index_idx = 0
+        
+        stream_idx, total, rem = 0, 0, 0.0
+        for x in flux.list:
+            y = x * factor + rem
+            f = round(y)
+            rem = y - f
+            emit(f)
+
+        # We may not have enough flux to get to the final index value.
+        # Generate a dummy flux just enough to get us there.
+        if index_idx < len(index):
+            emit(math.ceil(index[index_idx] - total) + 1)
+        # A dummy cell so that we definitely have *something* after the
+        # final OOB.Index, so that all parsers should register the Index.
+        emit(round(sck*12e-6)) # 12us
+
+        # Emit StreamEnd and EOF blocks to terminate the stream.
+        dat += struct.pack('<2BH2I', Op.OOB, OOB.StreamEnd, 8, stream_idx, 0)
+        dat += struct.pack('<2BH', Op.OOB, OOB.EOF, 0x0d0d)
+
+        name = self.basename + '%02d.%d.raw' % (cyl, side)
+        with open(name, ('wb','xb')[self.noclobber]) as f:
+                f.write(dat)
+
+
+    def __enter__(self):
+        return self
+    def __exit__(self, type, value, tb):
+        pass
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/mgt.py

@@ -0,0 +1,15 @@
+# greaseweazle/image/mgt.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 diskstack._vendor.greaseweazle.image.img import IMG
+
+class MGT(IMG):
+    default_format = 'ibm.800'
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/msa.py

@@ -0,0 +1,153 @@
+# greaseweazle/image/msa.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 typing import Dict, Tuple, Optional
+
+import struct
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec.ibm import ibm
+from .image import Image
+
+class MSA(Image):
+
+    def __init__(self, name: str, _fmt):
+        self.to_track: Dict[Tuple[int,int],ibm.IBMTrack_Fixed] = dict()
+        self.filename = name
+
+
+    def from_bytes(self, dat: bytes) -> None:
+
+        id, spt, nsides, st, et = struct.unpack('>2s4H', dat[0:10])
+
+        error.check(id == b'\x0e\x0f', 'MSA: Unrecognised signature')
+
+        nsides += 1 
+        error.check(1 <= nsides <= 2, f'MSA: Bad number of sides: {nsides}')
+
+        idx = 10
+        for cyl in range(st, et+1):
+            for head in range(nsides):
+                nbytes, = struct.unpack('>H', dat[idx:idx+2])
+                error.check(nbytes <= spt*512, 'MSA: Track data too long')
+                idx += 2
+                td = dat[idx:idx+nbytes]
+                idx += nbytes
+
+                if nbytes == spt*512:
+                    tdat = td
+                else:
+                    tdat = bytearray()
+                    tidx = 0
+                    while tidx < len(td):
+                        b, tidx = td[tidx], tidx+1
+                        if b == 0xe5:
+                            b, runlen = struct.unpack('>BH', td[tidx:tidx+3])
+                            tidx += 3
+                            tdat += bytes([b]) * runlen
+                        else:
+                            tdat.append(b)
+                    error.check(len(tdat) == spt*512,
+                                'MSA: Bad track compressed data')
+
+                track = ibm.IBMTrack_FixedDef('ibm.mfm')
+                track.iam = False
+                track.rate = 250
+                track.rpm = 300
+                track.secs = spt
+                track.sz = [2]
+                if spt <= 9:
+                    track.gap3 = 84
+                    track.cskew = 4
+                    track.hskew = 2
+                elif spt == 10:
+                    track.gap3 = 30
+                else:
+                    track.gap3 = 3
+                    track.rate = 261
+                track.finalise()
+                t = track.mk_track(cyl, head)
+
+                for n,s in enumerate(t.sectors):
+                    s.crc = s.idam.crc = s.dam.crc = 0
+                    s.idam.c, s.idam.h, s.idam.r, s.idam.n = cyl, head, n+1, 2
+                    s.dam.data = tdat[n*512:(n+1)*512]
+
+                self.to_track[cyl, head] = t
+
+
+    def get_track(self, cyl: int, side: int) -> Optional[ibm.IBMTrack_Fixed]:
+        if (cyl,side) not in self.to_track:
+            return None
+        return self.to_track[cyl,side]
+
+
+    def emit_track(self, cyl: int, side: int, track) -> None:
+        self.to_track[cyl,side] = track
+
+
+    def get_image(self) -> bytes:
+
+        n_side = max(self.to_track.keys(), default=(0,0), key=lambda x:x[1])[1]
+        n_side += 1
+        st = min(self.to_track.keys(), default=(0,), key=lambda x:x[0])[0]
+        et = max(self.to_track.keys(), default=(0,), key=lambda x:x[0])[0]
+        
+        dat = bytearray()
+        spt = None
+        
+        for c in range(st,et+1):
+            for h in range(n_side):
+
+                # Grab the IBM MFM track data. Perform sanity checks.
+                error.check((c,h) in self.to_track,
+                            f'MSA: Missing track {c}.{h} in output')
+                track = self.to_track[c,h]
+                error.check(isinstance(track, ibm.IBMTrack_Fixed),
+                            f'MSA: Track {c}.{h} is not an IBM track: '
+                            'Maybe missing --format= option?')
+                tdat = track.get_img_track()
+                if spt is None:
+                    spt = len(track.sectors)
+                error.check(spt == len(track.sectors),
+                            f'MSA: Track {c}.{h} has incorrect sectors per '
+                            f'track ({spt} != {len(track.sectors)})')
+
+                # Compress the track data.
+                td = bytearray()
+                tidx, runlen, runbyte = 0, 0, 0
+                while tidx < len(tdat):
+                    b, tidx = tdat[tidx], tidx+1
+                    if b != runbyte:
+                        if runlen < 4 and runbyte != 0xe5:
+                            td += bytes([runbyte]) * runlen
+                        elif runlen != 0:
+                            td += struct.pack('>2BH', 0xe5, runbyte, runlen)
+                        runlen = 0
+                    runbyte = b
+                    runlen += 1
+                if runlen < 4 and runbyte != 0xe5:
+                    td += bytes([runbyte]) * runlen
+                elif runlen != 0:
+                    td += struct.pack('>2BH', 0xe5, runbyte, runlen)
+
+                # Use the compressed data if it's shorter than raw data.
+                if len(td) < len(tdat):
+                    dat += struct.pack('>H', len(td))
+                    dat += td
+                else:
+                    dat += struct.pack('>H', len(tdat))
+                    dat += tdat
+
+        header = struct.pack('>2s4H', b'\x0e\x0f', spt, n_side-1, st, et)
+
+        return header + dat
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/nfd.py

@@ -0,0 +1,113 @@
+# greaseweazle/image/nfd.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 typing import Dict, Tuple, Optional, List
+
+import struct
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec.ibm import ibm
+from .image import Image, OptDict
+
+TrackDict = Dict[Tuple[int, int], ibm.IBMTrack_Fixed]
+
+
+class NFD(Image):
+
+    read_only = True
+
+    def __init__(self, name: str, _fmt):
+        self.to_track: TrackDict = dict()
+        self.filename = name
+
+    @classmethod
+    def from_file(cls, name: str, _fmt, opts: OptDict) -> Image:
+
+        nfd = cls(name, _fmt)
+        nfd.apply_r_opts(opts)
+
+        with open(name, 'rb') as f:
+            header = struct.unpack('<15sx256sLBB10x', f.read(288))
+            file_id, comment_bytes, header_size, write_protect, heads = header
+            if file_id == b'T98FDDIMAGE.R1\0':
+                raise error.Fatal('NFD: r1 format images not supported')
+            if file_id != b'T98FDDIMAGE.R0\0':
+                raise error.Fatal('NFD: not a NFD image')
+            if heads != 2:
+                raise error.Fatal('NFD: heads != 2 not supported')
+            comment = comment_bytes.decode('sjis')
+            print('NFD: comment:', comment)
+            if write_protect != 0:
+                print('NFD: disk is write protected')
+            for physical_track in range(0, 163):
+                secs: List[Tuple[int, int, int, int]] = []
+                track = None
+                track_mfm = 0
+                for _ in range(1, 27):
+                    sector_header = struct.unpack('<11B5x', f.read(16))
+                    c, h, r, n, mfm, ddam, status, st0, st1, st2, pda = sector_header
+                    if c == 0xff:
+                        continue
+                    if track is None:
+                        track_mfm = mfm
+                        if mfm != 0:
+                            track = ibm.IBMTrack_FixedDef('ibm.mfm')
+                            track.rate = 500
+                        else:
+                            track = ibm.IBMTrack_FixedDef('ibm.fm')
+                            track.rate = 250
+                        track.rpm = 360
+                    else:
+                        if track_mfm != mfm:
+                            raise error.Fatal(
+                                'NFD: mixed FM and MFM tracks not supported')
+                    if ddam != 0:
+                        raise error.Fatal('NFD: DDAM not supported')
+                    if status != 0:
+                        raise error.Fatal(
+                            f'NFD: Status {status:%02x} not supported')
+                    if h not in (0, 1):
+                        raise error.Fatal(f'NFD: Invalid head value {h}')
+                    if h == 0 and st0 != 0x00:
+                        raise error.Fatal(f'NFD: ST0 {st0:%02x} not supported')
+                    if h == 1 and st0 != 0x04:
+                        raise error.Fatal(f'NFD: ST0 {st0:%02x} not supported')
+                    if st1 != 0:
+                        raise error.Fatal(f'NFD: ST1 {st1:%02x} not supported')
+                    if st2 != 0:
+                        raise error.Fatal(f'NFD: ST2 {st2:%02x} not supported')
+                    if pda != 0x90:
+                        raise error.Fatal(f'NFD: PDA {pda:%02x} not supported')
+                    secs.append((c, h, r, n))
+                if track is not None:
+                    assert track is not None
+                    track.secs = len(secs)
+                    track.sz = [x[3] for x in secs]
+                    track.finalise()
+                    t = ibm.IBMTrack_Fixed.from_config(
+                        track, physical_track // 2, physical_track % 2,
+                        warn_on_oversize=True)
+                    for nr, s in enumerate(t.sectors):
+                        c, h, r, n = secs[nr]
+                        s.crc = s.idam.crc = s.dam.crc = 0
+                        s.idam.c, s.idam.h, s.idam.r, s.idam.n = c, h, r, n
+                    nfd.to_track[physical_track // 2, physical_track % 2] = t
+            f.seek(header_size)
+            for _, t in nfd.to_track.items():
+                for s in t.sectors:
+                    s.dam.data = f.read(128 << s.idam.n)
+
+        return nfd
+
+    def get_track(self, cyl: int, side: int) -> Optional[ibm.IBMTrack_Fixed]:
+        if (cyl, side) not in self.to_track:
+            return None
+        return self.to_track[cyl, side]
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/nsi.py

@@ -0,0 +1,47 @@
+# greaseweazle/image/nsi.py
+#
+# North Star Image order:
+#  1. All tracks of side 0
+#  2. All tracks of side 1 (reverse order)
+#
+# 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>.
+
+import os
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.image.img import IMG_AutoFormat
+
+class NSI(IMG_AutoFormat):
+
+    @staticmethod
+    def format_from_file(name: str) -> str:
+        size = os.path.getsize(name)
+        if size == 1*35*10*256:
+            return 'northstar.fm.ss'
+#        if size == 2*35*10*256:
+#            return 'northstar.fm.ds'
+        if size == 1*35*10*512:
+            return 'northstar.mfm.ss'
+        if size == 2*35*10*512:
+            return 'northstar.mfm.ds'
+        raise error.Fatal(f'NSI: {name}: unrecognised file size')
+
+    def track_list(self):
+        t, l = self.fmt.tracks, []
+        prepend = False
+        for h in t.heads:
+            _l = []
+            for c in t.cyls:
+                _l.append((c,h))
+            if (h & 1) == 1:
+                _l.reverse()
+            l += _l
+        return l
+
+
+# Local variables:
+# python-indent: 4
+# End: