diskstack 1.0.0__py3-none-any.whl

diskstack/_vendor/greaseweazle/codec/codec.py

@@ -0,0 +1,362 @@
+# greaseweazle/codec/codec.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 Dict, List, Tuple, Optional
+
+import os.path, re
+import importlib.resources
+from copy import copy
+from abc import abstractmethod
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec import codec
+from diskstack._vendor.greaseweazle.tools import util
+from diskstack._vendor.greaseweazle.track import MasterTrack, PLL
+from diskstack._vendor.greaseweazle.flux import Flux, HasFlux, WriteoutFlux
+
+
+class Codec:
+
+    @property
+    @abstractmethod
+    def nsec(self) -> int:
+        ...
+
+    @abstractmethod
+    def summary_string(self) -> str:
+        ...
+
+    @abstractmethod
+    def has_sec(self, sec_id: int) -> bool:
+        ...
+
+    @abstractmethod
+    def nr_missing(self) -> int:
+        ...
+
+    @abstractmethod
+    def get_img_track(self) -> bytearray:
+        ...
+
+    @abstractmethod
+    def set_img_track(self, tdat: bytes) -> int:
+        ...
+
+    @abstractmethod
+    def decode_flux(self, track: HasFlux, pll: Optional[PLL] = None) -> None:
+        ...
+
+    @abstractmethod
+    def master_track(self) -> MasterTrack:
+        ...
+
+    def flux(self) -> Flux:
+        return self.master_track().flux()
+
+    def flux_for_writeout(self, cue_at_index) -> WriteoutFlux:
+        return self.master_track().flux_for_writeout(cue_at_index)
+
+
+class TrackDef:
+
+    default_revs: float
+
+    @abstractmethod
+    def add_param(self, key: str, val) -> None:
+        ...
+
+    @abstractmethod
+    def finalise(self) -> None:
+        ...
+
+    @abstractmethod
+    def mk_track(self, cyl: int, head: int) -> codec.Codec:
+        ...
+    
+
+class DiskDef:
+
+    def __init__(self) -> None:
+        self.cyls: Optional[int] = None
+        self.heads: Optional[int] = None
+        self.track_map: Dict[Tuple[int,int],TrackDef] = dict()
+
+    def add_param(self, key: str, val: str) -> None:
+        if key == 'cyls':
+            n = int(val)
+            error.check(1 <= n <= 255, '%s out of range' % key)
+            self.cyls = n
+        elif key == 'heads':
+            n = int(val)
+            error.check(1 <= n <= 2, '%s out of range' % key)
+            self.heads = n
+        else:
+            raise error.Fatal('unrecognised disk option: %s' % key)
+
+    def finalise(self):
+        error.check(self.cyls is not None, 'missing cyls')
+        error.check(self.heads is not None, 'missing heads')
+        self.tracks = util.TrackSet(self.trackset())
+
+    def trackset(self):
+        s = 'c=0'
+        if self.cyls > 1:
+            s += '-' + str(self.cyls-1)
+        s += ':h=0'
+        if self.heads > 1:
+            s += '-' + str(self.heads-1)
+        return s
+
+    def mk_track(self, cyl: int, head: int) -> Optional[codec.Codec]:
+        if (cyl, head) not in self.track_map:
+            return None
+        return self.track_map[cyl, head].mk_track(cyl, head)
+    
+    def decode_flux(self, cyl: int, head: int,
+                    track: HasFlux) -> Optional[codec.Codec]:
+        t = self.mk_track(cyl, head)
+        if t is not None:
+            t.decode_flux(track)
+        return t
+
+    @property
+    def default_revs(self) -> float:
+        return max([x.default_revs for x in self.track_map.values()])
+
+
+class DiskDef_File:
+    def __init__(self, name: Optional[str],
+                 parent: Optional[DiskDef_File] = None) -> None:
+        self.path: Optional[str] = None
+        self.name: str = 'diskdefs.cfg' if name is None else name
+        if name is None or (parent and not parent.path):
+            res = importlib.resources.files(
+                'diskstack._vendor.greaseweazle.data')
+            with res.joinpath(self.name).open('r') as f:
+                self.lines = f.readlines()
+        else:
+            if parent:
+                assert parent.path # mypy
+                self.path = os.path.join(os.path.dirname(parent.path),
+                                         self.name)
+            else:
+                self.path = os.path.expanduser(self.name)
+            with open(self.path, 'r') as f:
+                self.lines = f.readlines()
+
+
+# Import the TrackDef subclasses
+from diskstack._vendor.greaseweazle.codec import bitcell
+from diskstack._vendor.greaseweazle.codec.ibm import ibm
+from diskstack._vendor.greaseweazle.codec.amiga import amigados
+from diskstack._vendor.greaseweazle.codec.macintosh import mac_gcr
+from diskstack._vendor.greaseweazle.codec.commodore import c64_gcr
+from diskstack._vendor.greaseweazle.codec.apple2 import apple2_gcr
+from diskstack._vendor.greaseweazle.codec.hp import hp_mmfm
+from diskstack._vendor.greaseweazle.codec.northstar import northstar
+from diskstack._vendor.greaseweazle.codec.micropolis import micropolis
+from diskstack._vendor.greaseweazle.codec.datageneral import datageneral
+
+def mk_trackdef(format_name: str) -> TrackDef:
+    if format_name in ['amiga.amigados']:
+        return amigados.AmigaDOSDef(format_name)
+    if format_name in ['ibm.mfm', 'ibm.fm', 'dec.rx02']:
+        return ibm.IBMTrack_FixedDef(format_name)
+    if format_name in ['ibm.scan']:
+        return ibm.IBMTrack_ScanDef(format_name)
+    if format_name in ['mac.gcr']:
+        return mac_gcr.MacGCRDef(format_name)
+    if format_name in ['c64.gcr']:
+        return c64_gcr.C64GCRDef(format_name)
+    if format_name in ['hp.mmfm']:
+        return hp_mmfm.HPMMFMDef(format_name)
+    if format_name in ['northstar']:
+        return northstar.NorthStarDef(format_name)
+    if format_name in ['micropolis']:
+        return micropolis.MicropolisDef(format_name)
+    if format_name in ['apple2.gcr']:
+        return apple2_gcr.Apple2GCRDef(format_name)
+    if format_name in ['bitcell']:
+        return bitcell.BitcellTrackDef(format_name)
+    if format_name in ['datageneral']:
+        return datageneral.DataGeneralDef(format_name)
+    raise error.Fatal('unrecognised format name: %s' % format_name)
+
+
+class ParseMode:
+    Outer = 0
+    Disk  = 1
+    Track = 2
+
+def _get_diskdef(
+        format_name: str,
+        prefix: str,
+        diskdef_file: DiskDef_File
+) -> Optional[DiskDef]:
+
+    parse_mode = ParseMode.Outer
+    active = False
+    disk: Optional[DiskDef] = None
+    track: Optional[TrackDef] = None
+
+    for linenr, l in enumerate(diskdef_file.lines, start=1):
+        try:
+            # Strip comments and whitespace.
+            match = re.match(r'\s*([^#]*)', l)
+            assert match is not None # mypy
+            t = match.group(1).strip()
+
+            # Skip empty lines.
+            if not t:
+                continue
+
+            if parse_mode == ParseMode.Outer:
+                disk_match = re.match(r'disk\s+([\w,.-]+)', t)
+                if disk_match:
+                    parse_mode = ParseMode.Disk
+                    active = ((prefix + disk_match.group(1).casefold())
+                              == format_name)
+                    if active:
+                        disk = DiskDef()
+                else:
+                    import_match = re.match(r'import\s+([\w,.-]*)\s*"([^"]+)"',
+                                            t)
+                    error.check(import_match is not None, 'syntax error')
+                    assert import_match is not None # mypy
+                    sub_prefix = prefix + import_match.group(1).casefold()
+                    if format_name.startswith(sub_prefix):
+                        disk = _get_diskdef(format_name, sub_prefix,
+                                            DiskDef_File(
+                                                name = import_match.group(2),
+                                                parent = diskdef_file))
+                        if disk:
+                            break
+
+            elif parse_mode == ParseMode.Disk:
+                if t == 'end':
+                    parse_mode = ParseMode.Outer
+                    active = False
+                    if disk:
+                        break
+                    continue
+                tracks_match = re.match(r'tracks\s+([0-9,.*-]+)'
+                                        r'\s+([\w,.-]+)', t)
+                if tracks_match:
+                    parse_mode = ParseMode.Track
+                    if not active:
+                        continue
+                    assert disk is not None # mypy
+                    error.check(disk.cyls is not None, 'missing cyls')
+                    error.check(disk.heads is not None, 'missing heads')
+                    assert disk.cyls is not None # mypy
+                    assert disk.heads is not None # mypy
+                    track = mk_trackdef(tracks_match.group(2))
+                    for x in tracks_match.group(1).split(','):
+                        if x == '*':
+                            for c in range(disk.cyls):
+                                for hd in range(disk.heads):
+                                    if (c,hd) not in disk.track_map:
+                                        disk.track_map[c,hd] = track
+                        else:
+                            t_match = re.match(r'(\d+)(?:-(\d+))?'
+                                               r'(?:\.([01]))?', x)
+                            error.check(t_match is not None,
+                                        'bad track specifier')
+                            assert t_match is not None # mypy
+                            s = int(t_match.group(1))
+                            e = t_match.group(2)
+                            e = s if e is None else int(e)
+                            h = t_match.group(3)
+                            if h is None:
+                                h = list(range(disk.heads))
+                            else:
+                                error.check(int(h) < disk.heads,
+                                            'head out of range')
+                                h = [int(h)]
+                            error.check(0 <= s < disk.cyls
+                                        and 0 <= e < disk.cyls
+                                        and s <= e,
+                                        'cylinder out of range')
+                            for c in range(s,e+1):
+                                for hd in h:
+                                    disk.track_map[c,hd] = track
+                    continue
+
+                if not active:
+                    continue
+                assert disk is not None # mypy
+
+                keyval_match = re.match(r'([a-zA-Z0-9:,._-]+)\s*='
+                                        r'\s*([a-zA-Z0-9:,._-]+)', t)
+                error.check(keyval_match is not None, 'syntax error')
+                assert keyval_match is not None # mypy
+                disk.add_param(keyval_match.group(1),
+                               keyval_match.group(2))
+
+            elif parse_mode == ParseMode.Track:
+                if t == 'end':
+                    parse_mode = ParseMode.Disk
+                    if track is not None:
+                        track.finalise()
+                        track = None
+                    continue
+
+                if not active:
+                    continue
+                assert track is not None # mypy
+
+                keyval_match = re.match(r'([a-zA-Z0-9:,._-]+)\s*='
+                                        r'\s*([a-zA-Z0-9:,._*-]+)', t)
+                error.check(keyval_match is not None, 'syntax error')
+                assert keyval_match is not None # mypy
+                track.add_param(keyval_match.group(1),
+                                keyval_match.group(2))
+
+        except Exception as err:
+            if err.args and isinstance(x := err.args[0], str):
+                ctxt = f'At {diskdef_file.name}, line {linenr}:'
+                ctxt += '\n' if x.startswith('At') else ' '
+                err.args = (ctxt + x,) + err.args[1:]
+            raise
+
+    return disk
+
+def get_diskdef(
+        format_name: str,
+        diskdef_filename: Optional[str] = None
+) -> Optional[DiskDef]:
+    diskdef_file = DiskDef_File(name = diskdef_filename)
+    disk = _get_diskdef(format_name.casefold(), '', diskdef_file)
+    if disk is None:
+        return None
+    disk.finalise()
+    return disk
+
+def get_all_formats(prefix: str, diskdef_file: DiskDef_File) -> List[str]:
+    formats = []
+    for l in diskdef_file.lines:
+        disk_match = re.match(r'\s*disk\s+([\w,.-]+)', l)
+        if disk_match:
+            formats.append(prefix + disk_match.group(1))
+        import_match = re.match(r'\s*import\s+([\w,.-]*)\s*"([^"]+)"', l)
+        if import_match:
+            formats += get_all_formats(
+                prefix + import_match.group(1),
+                DiskDef_File(
+                    name = import_match.group(2),
+                    parent = diskdef_file))
+    return formats
+
+def print_formats(diskdef_filename: Optional[str] = None) -> str:
+    formats = get_all_formats('', DiskDef_File(name = diskdef_filename))
+    formats.sort()
+    return util.columnify(formats)
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/codec/commodore/c64_gcr.py

@@ -0,0 +1,229 @@
+# greaseweazle/codec/c64/c64_gcr.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 List, Optional, Tuple
+
+import struct
+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.track import MasterTrack, PLL, PLLTrack
+from diskstack._vendor.greaseweazle.flux import Flux, HasFlux
+
+default_revs = 1.1
+
+# GCR 0xffd49 = ...11111 01010 01001 = [sync] A 9 -> [sync] 08 (hdr block id)
+sector_sync = bitarray(endian='big')
+sector_sync.frombytes(b'\xff\xd4\x90')
+sector_sync = sector_sync[:20]
+
+# GCR 0xffd57 = ...11111 01010 10111 = [sync] A 17 -> [sync] 07 (data block id)
+data_sync = bitarray(endian='big')
+data_sync.frombytes(b'\xff\xd5\x70')
+data_sync = data_sync[:20]
+
+bad_sector = b'-=[BAD SECTOR]=-' * 16
+
+class C64GCR(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
+        self.disk_id: Optional[int] = None
+        error.check(optimised.enabled,
+                    'Commodore 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 = "Commodore GCR (%d/%d sectors)" % (nsec - nbad, nsec)
+        return s
+
+    def set_disk_id(self, disk_id: int):
+        assert self.disk_id is None
+        self.disk_id = disk_id
+
+    # private
+    def add(self, sec_id, data) -> None:
+        assert not self.has_sec(sec_id)
+        self.sector[sec_id] = data
+
+    # private
+    def tracknr(self) -> int:
+        return self.head*35 + self.cyl + 1
+
+    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
+        return tdat
+
+    def set_img_track(self, tdat: bytes) -> int:
+        totsize = self.nsec * 256
+        if len(tdat) < totsize:
+            tdat += bytes(totsize - len(tdat))
+        for sec in range(self.nsec):
+            self.sector[sec] = tdat[sec*256:(sec+1)*256]
+        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,
+                       lowpass_thresh = 2.5e-6)
+        bits, _ = raw.get_all_data()
+
+        for offs in bits.search(sector_sync):
+
+            if self.nr_missing() == 0:
+                break
+
+            # Decode header, 8 bytes (=10 bytes GCR):
+            # 0x08, csum, sector, track, disk_id[2], gap[2]
+            offs += 10
+            sec = bits[offs:offs+10*8].tobytes()
+            if len(sec) != 10:
+                continue
+            hdr = optimised.decode_c64_gcr(sec)
+            sum = 0
+            for x in hdr[1:6]:
+                sum ^= x
+            if sum != 0:
+                continue
+            sec_id, cyl, disk_id = struct.unpack('>2BH', hdr[2:6])
+            if (cyl != self.tracknr() or sec_id >= self.nsec):
+                print('T%d.%d: Ignoring unexpected sector C:%d S:%d ID:%04x'
+                      % (self.cyl, self.head, cyl, sec_id, disk_id))
+                continue
+            if self.disk_id is None:
+                self.disk_id = disk_id
+            elif self.disk_id != disk_id:
+                print('T%d.%d: Expected ID %04x in sector C:%d S:%d ID:%04x'
+                      % (self.cyl, self.head, self.disk_id,
+                         cyl, sec_id, disk_id))
+                continue
+            if self.has_sec(sec_id):
+                continue
+
+            # Find data
+            offs += 8*8
+            dat_offs = list(bits[offs:offs+100*8].search(data_sync))
+            if len(dat_offs) != 1:
+                continue
+            offs += dat_offs[0]
+
+            # Decode data, 260 bytes (=325 bytes GCR):
+            # 0x07, data[256], csum, gap[2]
+            offs += 10
+            sec = bits[offs:offs+260*10].tobytes()
+            if len(sec) != 325:
+                continue
+            sec = optimised.decode_c64_gcr(sec)
+            sum = 0
+            for x in sec[1:258]:
+                sum ^= x
+            if sum != 0:
+                continue
+
+            self.add(sec_id, sec[1:257])
+
+
+    def master_track(self) -> MasterTrack:
+
+        # Post-index track gap.
+        t = bytes([0x55] * 10)
+
+        for sec_id in range(self.nsec):
+            sector = self.sector[sec_id]
+            data = bad_sector if sector is None else sector
+            # Header
+            disk_id = self.disk_id if self.disk_id is not None else 0
+            hdr = struct.pack('>2BH', sec_id, self.tracknr(), disk_id)
+            sum = 0
+            for x in hdr:
+                sum ^= x
+            hdr = bytes([0x08, sum]) + hdr + bytes([0x0f, 0x0f])
+            t += b'\xff' * 5 # sync
+            t += optimised.encode_c64_gcr(hdr)
+            t += b'\x55' * 9 # gap
+            # Data
+            t += b'\xff' * 5 # sync
+            sum = 0
+            for x in data:
+                sum ^= x
+            t += optimised.encode_c64_gcr(
+                bytes([0x07]) + data + bytes([sum, 0x0f, 0x0f]))
+            t += b'\x55' * 9 # gap
+
+        # Add the pre-index gap.
+        tlen = int((self.time_per_rev / self.clock)) & ~31
+        t += bytes([0x55] * (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 C64GCRDef(codec.TrackDef):
+
+    default_revs = default_revs
+
+    def __init__(self, format_name: str):
+        self.secs: Optional[int] = None
+        self.clock: Optional[float] = None
+        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
+        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')
+        self.finalised = True
+
+    def mk_track(self, cyl: int, head: int) -> C64GCR:
+        return C64GCR(cyl, head, self)
+
+
+# Local variables:
+# python-indent: 4
+# End: