diskstack 1.0.0__py3-none-any.whl

diskstack/__init__.py

@@ -0,0 +1,5 @@
+"""Merge several dumps of one floppy disk into the best possible image."""
+
+__version__ = '1.0.0'
+
+__all__ = ['__version__']

diskstack/_vendor/greaseweazle/COPYING

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

diskstack/_vendor/greaseweazle/__init__.py

@@ -0,0 +1,2 @@
+__version__ = 'vendored-26690f89967d'
+from diskstack._vendor.greaseweazle.codec import codec  # noqa: F401

diskstack/_vendor/greaseweazle/codec/amiga/amigados.py

@@ -0,0 +1,221 @@
+# greaseweazle/codec/amiga/amigados.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
+import itertools as it
+from bitarray import bitarray
+
+from diskstack._vendor.greaseweazle import error
+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.1
+
+sync_bytes = b'\x44\x89\x44\x89'
+sync = bitarray(endian='big')
+sync.frombytes(sync_bytes)
+
+bad_sector = b'-=[BAD SECTOR]=-' * 32
+
+class AmigaDOS(codec.Codec):
+
+    # Subclasses must define these
+    nsec: int
+    clock: float
+
+    time_per_rev = 0.2
+
+    verify_revs = default_revs
+
+    def __init__(self, cyl: int, head: int):
+        self.tracknr = cyl*2 + head
+        self.sector: List[Optional[Tuple[bytes,bytes]]]
+        self.sector = [None] * self.nsec
+        self.map: List[Optional[int]]
+        self.map = [None] * self.nsec
+
+    def summary_string(self) -> str:
+        nsec, nbad = self.nsec, self.nr_missing()
+        s = "AmigaDOS (%d/%d sectors)" % (nsec - nbad, nsec)
+        return s
+
+    # private
+    def exists(self, sec_id, togo) -> bool:
+        return ((self.sector[sec_id] is not None)
+                or (self.map[self.nsec-togo] is not None))
+
+    # private
+    def add(self, sec_id, togo, label, data) -> None:
+        assert not self.exists(sec_id, togo)
+        self.sector[sec_id] = label, data
+        self.map[self.nsec-togo] = sec_id
+
+    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[1] 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))
+        self.map = list(range(self.nsec))
+        for sec in range(self.nsec):
+            self.sector[sec] = bytes(16), 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(sync):
+
+            if self.nr_missing() == 0:
+                break
+
+            sec = bits[offs:offs+544*16].tobytes()
+            if len(sec) != 1088:
+                continue
+
+            header = decode(sec[4:12])
+            format, track, sec_id, togo = tuple(header)
+            if format != 0xff or track != self.tracknr \
+               or not(sec_id < self.nsec and 0 < togo <= self.nsec) \
+               or self.exists(sec_id, togo):
+                continue
+
+            label = decode(sec[12:44])
+            hsum, = struct.unpack('>I', decode(sec[44:52]))
+            if hsum != checksum(header + label):
+                continue
+
+            dsum, = struct.unpack('>I', decode(sec[52:60]))
+            data = decode(sec[60:1084])
+            gap = decode(sec[1084:1088])
+            if dsum != checksum(data):
+                continue;
+
+            self.add(sec_id, togo, label, data)
+
+
+    def master_track(self) -> MasterTrack:
+
+        # List of sector IDs missing from the sector map:
+        missing = iter([x for x in range(self.nsec) if not x in self.map])
+        # Sector map with the missing entries filled in:
+        full_map = [next(missing) if x is None else x for x in self.map]
+
+        # Post-index track gap.
+        t = encode(bytes(128 * (self.nsec//11)))
+
+        for nr, sec_id in zip(range(self.nsec), full_map):
+            sector = self.sector[sec_id]
+            label, data = (bytes(16), bad_sector) if sector is None else sector
+            header = bytes([0xff, self.tracknr, sec_id, self.nsec-nr])
+            t += sync_bytes
+            t += encode(header)
+            t += encode(label)
+            t += encode(struct.pack('>I', checksum(header + label)))
+            t += encode(struct.pack('>I', checksum(data)))
+            t += encode(data)
+            t += encode(bytes(2))
+
+        # Add the pre-index gap.
+        tlen = (int((self.time_per_rev / self.clock)) + 31) & ~31
+        t += bytes(tlen//8-len(t))
+
+        track = MasterTrack(
+            bits = ibm.mfm_encode(t),
+            time_per_rev = self.time_per_rev)
+        track.verify = self
+        return track
+
+
+    def verify_track(self, flux):
+        cyl = self.tracknr // 2
+        head = self.tracknr & 1
+        readback_track = self.__class__(cyl, head)
+        readback_track.decode_flux(flux)
+        return (readback_track.nr_missing() == 0
+                and self.sector == readback_track.sector)
+
+
+class AmigaDOS_DD(AmigaDOS):
+    nsec = 11
+    clock = 14/7093790
+
+class AmigaDOS_HD(AmigaDOS):
+    nsec = 22
+    clock = AmigaDOS_DD.clock / 2
+
+
+class AmigaDOSDef(codec.TrackDef):
+
+    default_revs = default_revs
+
+    def __init__(self, format_name: str):
+        self.secs = None
+        self.finalised = False
+
+    def add_param(self, key: str, val) -> None:
+        if key == 'secs':
+            val = int(val)
+            error.check(val in [11, 22], '%s out of range' % key)
+            self.secs = 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')
+        self.finalised = True
+
+    def mk_track(self, cyl: int, head: int) -> AmigaDOS:
+        t: AmigaDOS
+        if self.secs == 11:
+            t = AmigaDOS_DD(cyl, head)
+        else:
+            t = AmigaDOS_HD(cyl, head)
+        return t
+
+
+def encode(dat):
+    return bytes(it.chain(map(lambda x: (x >> 1) & 0x55, dat),
+                          map(lambda x: x & 0x55, dat)))
+
+
+def decode(dat):
+    length = len(dat)//2
+    return bytes(map(lambda x, y: (x << 1 & 0xaa) | (y & 0x55),
+                     it.islice(dat, 0, length),
+                     it.islice(dat, length, None)))
+
+
+def checksum(dat):
+    csum = 0
+    for i in range(0, len(dat), 4):
+        csum ^= struct.unpack('>I', dat[i:i+4])[0]
+    return (csum ^ (csum>>1)) & 0x55555555
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/codec/apple2/apple2_gcr.py

@@ -0,0 +1,223 @@
+# greaseweazle/codec/apple2/apple2_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
+
+gap4 = bitarray([1], endian='big')
+ff40 = bitarray([1]*8 + [0]*2, endian='big')
+ff32 = ff40[:8]
+
+addr_sync = bitarray(endian='big')
+addr_sync.frombytes(b'\xd5\xaa\x96')
+
+data_sync = bitarray(endian='big')
+data_sync.frombytes(b'\xd5\xaa\xad')
+
+trailer = bitarray(endian='big')
+trailer.frombytes(b'\xde\xaa\xeb')
+
+bad_sector = b'-=[BAD SECTOR]=-' * 16
+
+class Apple2GCR(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.vol_id: Optional[int] = None
+        error.check(optimised.enabled,
+                    'Apple2 GCR requires optimised C extension')
+
+    @property
+    def nsec(self) -> int:
+        return len(self.config.secs)
+
+    def summary_string(self) -> str:
+        nsec, nbad = self.nsec, self.nr_missing()
+        s = "Apple2 GCR (%d/%d sectors)" % (nsec - nbad, nsec)
+        return s
+
+    def set_vol_id(self, vol_id: int):
+        assert self.vol_id is None
+        self.vol_id = vol_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.cyl
+
+    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 i in self.config.secs:
+            sec = self.sector[i]
+            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 i,sec in enumerate(self.config.secs):
+            self.sector[sec] = tdat[i*256:(i+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(addr_sync):
+
+            if self.nr_missing() == 0:
+                break
+
+            # Decode header
+            offs += 3*8
+            sec = bits[offs:offs+8*8].tobytes()
+            if len(sec) != 8:
+                continue
+            hdr = map(lambda x: (x & x>>7) & 255,
+                      list(struct.unpack('>4H', sec)))
+            vol_id, trk_id, sec_id, csum = tuple(hdr)
+
+            # Validate header
+            if csum != vol_id ^ trk_id ^ sec_id:
+                continue
+            if (trk_id != self.tracknr() or sec_id >= self.nsec):
+                print('T%d.%d: Ignoring unexpected sector C:%d S:%d ID:%04x'
+                      % (self.cyl, self.head, trk_id, sec_id, vol_id))
+                continue
+            if self.vol_id is None:
+                self.vol_id = vol_id
+            elif self.vol_id != vol_id:
+                print('T%d.%d: Expected ID %04x in sector C:%d S:%d ID:%04x'
+                      % (self.cyl, self.head, self.vol_id,
+                         trk_id, sec_id, vol_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
+            sec, csum = optimised.decode_apple2_sector(
+                bits[offs+3*8:offs+400*8].tobytes())
+            if csum != 0:
+                continue
+
+            self.add(sec_id, sec)
+
+
+    def master_track(self) -> MasterTrack:
+
+        vol_id = self.vol_id if self.vol_id is not None else 254
+        trk_id = self.tracknr()
+
+        # Post-index track gap.
+        t = gap4 * 300
+
+        for sec_id in range(self.nsec):
+            sector = self.sector[sec_id]
+            data = bad_sector if sector is None else sector
+            t += ff40*18 + ff32 + addr_sync
+            t.frombytes(b''.join(map(
+                lambda x: bytes([x>>1 | 0xaa, x | 0xaa]),
+                [vol_id, trk_id, sec_id, vol_id ^ trk_id ^ sec_id])))
+            t += trailer + ff40*6 + data_sync
+            t.frombytes(optimised.encode_apple2_sector(data))
+            t += trailer
+
+        # Add the pre-index gap.
+        tlen = int((self.time_per_rev / self.clock))
+        t += gap4 * (tlen-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 Apple2GCRDef(codec.TrackDef):
+
+    default_revs = default_revs
+
+    def __init__(self, format_name: str):
+        self.secs: List[int] = []
+        self.clock: Optional[float] = None
+        self.finalised = False
+
+    def add_param(self, key: str, val) -> None:
+        if key == 'secs':
+            self.secs = []
+            for x in val.split(','):
+                self.secs.append(int(x))
+            rsecs = [-1] * len(self.secs)
+            for i,x in enumerate(self.secs):
+                error.check(x < len(rsecs), f'sector {x} is out of range')
+                error.check(rsecs[x] == -1, f'sector {x} is repeated')
+                rsecs[x] = i
+        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,
+                    'sector list not specified')
+        error.check(self.clock is not None,
+                    'clock period not specified')
+        self.finalised = True
+
+    def mk_track(self, cyl: int, head: int) -> Apple2GCR:
+        return Apple2GCR(cyl, head, self)
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/codec/bitcell.py

@@ -0,0 +1,117 @@
+# greaseweazle/codec/bitcell.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
+
+class BitcellTrack(codec.Codec):
+
+    nsec = 0
+    
+    def __init__(self, cyl: int, head: int, config):
+        self.cyl, self.head = cyl, head
+        self.config = config
+        self.clock = config.clock
+        self.raw: Optional[PLLTrack] = None
+
+    @property
+    def time_per_rev(self) -> float:
+        if self.raw is not None:
+            return self.raw.time_per_rev
+        if self.config.time_per_rev is not None:
+            return self.config.time_per_rev
+        return 0.2
+        
+    def summary_string(self) -> str:
+        if self.raw is None:
+            s = "Raw Bitcell (empty)"
+        else:
+            bits, _ = self.raw.get_revolution(0)
+            s = ("Raw Bitcell (%d bits, %.2fms)"
+                 % (len(bits), self.raw.time_per_rev*1000))
+        return s
+
+    def has_sec(self, sec_id: int) -> bool:
+        return False
+
+    def nr_missing(self) -> int:
+        return 0
+
+    def get_img_track(self) -> bytearray:
+        return bytearray()
+
+    def set_img_track(self, tdat: bytes) -> int:
+        return 0
+
+    def decode_flux(self, track: HasFlux, pll: Optional[PLL]=None) -> None:
+        flux = track.flux()
+        flux.cue_at_index()
+        time_per_rev = self.config.time_per_rev
+        if time_per_rev is None:
+            time_per_rev = flux.time_per_rev
+        self.raw = PLLTrack(time_per_rev = time_per_rev,
+                            clock = self.clock, data = flux, pll = pll)
+
+    def master_track(self) -> MasterTrack:
+        if self.raw is None:
+            nbytes = int(self.time_per_rev / self.clock) // 8
+            track = MasterTrack(bits = bytes(nbytes),
+                                time_per_rev = self.time_per_rev,
+                                weak = [(0,nbytes*8)])
+            track.force_random_weak = True
+            return track
+        bits, _ = self.raw.get_revolution(0)
+        track = MasterTrack(bits = bits, time_per_rev = self.time_per_rev)
+        return track
+
+
+class BitcellTrackDef(codec.TrackDef):
+
+    default_revs = default_revs
+
+    def __init__(self, format_name: str):
+        self.clock: Optional[float] = None
+        self.time_per_rev: 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
+        elif key == 'time_per_rev':
+            val = float(val)
+            self.time_per_rev = val
+        else:
+            raise error.Fatal('unrecognised track option %s' % key)
+
+    def finalise(self) -> None:
+        if self.finalised:
+            return
+        error.check(self.clock is not None,
+                    'clock period not specified')
+        self.finalised = True
+
+    def mk_track(self, cyl: int, head: int) -> BitcellTrack:
+        return BitcellTrack(cyl, head, self)
+
+
+# Local variables:
+# python-indent: 4
+# End: